null第六章 数组 指针与字符串第六章 数组 指针与字符串C++语言程序设计本章主要
内容
财务内部控制制度的内容财务内部控制制度的内容人员招聘与配置的内容项目成本控制的内容消防安全演练内容
本章主要内容数组
指针
动态存储分配
指针与数组
指针与函数
字符串数组的概念数组的概念数组是具有一定顺序关系的若干相同类型变量的集合体，组成数组的变量称为该数组的元素。
数组属于构造类型。 数 组一维数组的声明与引用一维数组的声明与引用一维数组的声明
类型说明符 数组名[ 常量表达式 ]；
例如：int a[10]; 表示 a 为整型数组，有10个元素：a[0]...a[9]引用
必须先声明，后使用。
只能逐个引用数组元素，而不能一次引用整个数组 例如：a[0]=a[5]+a[7]-a[2*3] 数 组例6. 1一维数组的声明与引用例6. 1一维数组的声明与引用#include
using namespace std;
int main()
{int A[10],B[10];
int i;
for(i=0;i<10;i++)
{
A[i]=i*2-1;
B[10-i-1]=A[i];
} for(i=0;i<10;i++)
{
cout<<"A["<
答案
八年级地理上册填图题岩土工程勘察试题省略号的作用及举例应急救援安全知识车间5s试题及答案
，计算并输出每组答案的正确率，直到输入ctrl+z为止。
每组连续输入5个答案，每个答案可以是'a'..'d'。 数 组null#include
using namespace std;
int main()
{
char key[ ]={'a','c','b','a','d'};
char c;
int ques=0,numques=5,numcorrect=0;
cout<<"Enter the "<
using namespace std;
void RowSum(int A[][4], int nrow)
{ int sum;
for (int i = 0; i < nrow; i++)
{
sum = 0;
for(int j = 0; j < 4; j++)
sum += A[i][j];
cout << "Sum of row " << i << " is " << sum << endl;
A[i][0]=sum;
}
} *二维数组做形参，第一维可以省略
若未省略，系统也会忽略nullint main()
{ int Table[3][4] = {{1,2,3,4},{2,3,4,5},{3,4,5,6}};
for (int i = 0; i < 3; i++)
{ for (int j = 0; j < 4; j++)
cout << Table[i][j] << " ";
cout << endl;
}
RowSum(Table,3);
for (int i = 0; i < 3; i++)
cout << Table[i][0]
}*null运行结果：
1 2 3 4
2 3 4 5
3 4 5 6
Sum of row 0 is 10
Sum of row 1 is 14
Sum of row 2 is 18
10 14 18
*对象数组对象数组声明：
类名 数组名[元素个数]；
访问方法：
通过下标访问
数组名[下标].成员名 数 组对象数组初始化对象数组初始化数组中每一个元素对象被创建时，系统都会调用类构造函数初始化该对象。
通过初始化列表赋值。
例： Point A[2]={Point(1,2),Point(3,4)};
如果没有为数组元素指定显式初始值，数组元素便使用默认值初始化（调用默认构造函数）。 数 组数组元素所属类的构造函数数组元素所属类的构造函数不声明构造函数，则采用默认构造函数。
各元素对象的初值要求为相同的值时，可以声明具有默认形参值的构造函数。
各元素对象的初值要求为不同的值时，需要声明带形参的构造函数。
当数组中每一个对象被删除时，系统都要调用一次析构函数。 数 组例6-3 对象数组应用举例例6-3 对象数组应用举例//Point.h
#if !defined _POINT_H
#define _POINT_H
class Point
{ public:
Point();
Point(int xx,int yy);
~Point();
void Move(int x,int y);
int GetX() {return X;}
int GetY() {return Y;}
private:
int X,Y;
};
#endif 数 组null//6-2.cpp
#include
using namespace std;
#include "Point.h"
Point::Point()
{ X=Y=0;
cout<<"Default Constructor called."<
#include "Point.h"
using namespace std;
int main()
{
cout<<"Entering main..."<
using namespace std;
int main()
{int *i_pointer; //声明int型指针i_pointer
int i; //声明int型数i
i_pointer=&i; //取i的地址赋给i_pointer
i=10; //int型数赋初值
cout<<"Output int i="<>a[i];
cout<>a[i];
cout<>a[i];
cout<
using namespace std;
int main()
{ int line1[]={1,0,0};//声明数组，矩阵的第一行
int line2[]={0,1,0};//声明数组，矩阵的第二行
int line3[]={0,0,1};//声明数组，矩阵的第三行
int *p_line[3]; //声明整型指针数组
p_line[0]=line1; //初始化指针数组元素
p_line[1]=line2;
p_line[2]=line3; 指 针null //输出单位矩阵
cout<<"Matrix test:"<
using namespace std;
int main()
{ int array2[2][3]={{11,12,13},{21,22,23}};
for(int i=0;i<2;i++)
{ cout<<*(array2+i)<
using namespace std;
void splitfloat(float x, int *intpart,
float *fracpart)
{ //形参intpart、 fracpart是指针
*intpart=int(x); // 取x的整数部分
*fracpart=x-*intpart; //取x的小数部分
} 指针与函数nullint main()
{
int i, n;
float x, f;
cout<<"Enter three(3) floating point numbers" << endl;
for (i = 0; i < 3; i++)
{
cin >> x;
splitfloat(x,&n,&f); //变量地址做实参
cout<<"Integer Part is "<< n <<" Fraction Part is "<
#include
using namespace std;
void Array_Ptr(long *P, int n)
{ int i;
cout<<"In func, address of array is " <
using namespace std;
const int N=6;
void print(const int *p,int n);
int main()
{ int array[N];
for(int i=0;i>array[i];
print(array,N);
} 指 针nullvoid print(const int *p, int n)
{
cout<<"{"<<*p;
for(int i=1;i
using namespace std;
void print_stuff(float data_to_ignore);
void print_message(float list_this_data);
void print_float(float data_to_print);
void (*function_pointer)(float);
int main()
{
float pi=(float)3.14159;
float two_pi=(float)2.0*pi; 指针与函数null print_stuff(pi);
function_pointer = print_stuff;
function_pointer(pi);
function_pointer = print_message;
function_pointer(two_pi);
function_pointer(13.0);
function_pointer = print_float;
function_pointer(pi);
print_float(pi);
}*nullvoid print_stuff(float data_to_ignore)
{ cout<<"This is the print stuff function.\n";
}
void print_message(float list_this_data)
{ cout<<"The data to be listed is "
<成员名
ptr->getx() 相当于 (*ptr).getx(); 指 针对象指针应用举例对象指针应用举例int main()
{
Point A(5,10);
Point *ptr;
ptr=&A;
int x;
x=ptr->GetX();
cout<X=xx;
this->Y=yy; 指 针指向类的非静态成员的指针指向类的非静态成员的指针通过指向成员的指针只能访问公有成员
声明指向成员的指针
声明指向公有数据成员的指针
类型说明符 类名::*指针名；
声明指向公有函数成员的指针
类型说明符 (类名::*指针名)(参数表)； 指 针指向类的非静态成员的指针指向类的非静态成员的指针指向数据成员的指针
说明指针应该指向哪个成员
指针名=&类名::数据成员名；
通过对象名（或对象指针）与成员指针结合来访问数据成员
对象名.* 类成员指针名
或：
对象指针名—>*类成员指针名 指 针指向类的非静态成员的指针指向类的非静态成员的指针指向函数成员的指针
初始化
指针名=类名::函数成员名；
通过对象名（或对象指针）与成员指针结合来访问函数成员
(对象名.* 类成员指针名)(参数表)
或：
(对象指针名—>*类成员指针名)(参数表) 指 针指向类的非静态成员的指针指向类的非静态成员的指针例6-13 访问对象的公有成员函数的不同方式
int main() //主函数
{ Point A(4,5); //声明对象A
Point *p1=&A; //声明对象指针并初始化
//声明成员函数指针并初始化
int (Point::*p_GetX)()=Point::GetX;
//（1）使用成员函数指针访问成员函数
cout<<(A.*p_GetX)()<GetX)()<
using namespace std;
class Point //Point类声明
{public: //外部接口
Point(int xx=0, int yy=0) {X=xx;Y=yy;countP++;}//构造函数
Point(Point &p); //拷贝构造函数
int GetX() {return X;}
int GetY() {return Y;}
static int countP; //静态数据成员引用性说明
private: //私有数据成员
int X,Y;
};
Point::Point(Point &p)
{ X=p.X; Y=p.Y; countP++; }
int Point::countP=0; //静态数据成员定义性说明 指 针nullint main() //主函数
{ //声明一个int型指针，指向类的静态成员
int *count=&Point::countP;
Point A(4,5); //声明对象A
cout<<"Point A,"<
using namespace std;
class Point
{public:
Point()
{ X=Y=0; cout<<"Default Constructor called.\n";}
Point(int xx,int yy)
{ X=xx;Y=yy; cout<< "Constructor called.\n"; }
~Point() { cout<<"Destructor called.\n"; }
int GetX(){return X;}
int GetY(){return Y;}
void Move(int x,int y) { X=x; Y=y; }
private:
int X,Y;
}; 动态存储分配nullint main()
{ cout<<"Step One:"<
using namespace std;
class Point
{ //类的声明同例6-16，略 };
int main()
{ Point *Ptr=new Point[2]; //创建对象数组
Ptr[0].Move(5,10); //通过指针访问数组元素的成员
Ptr[1].Move(15,20); //通过指针访问数组元素的成员
cout<<"Deleting..."<
using namespace std;
class Point
{ //类的声明同例6-16 … };
class ArrayOfPoints
{ public:
ArrayOfPoints(int n)
{ numberOfPoints=n; points=new Point[n];}
~ArrayOfPoints()
{ cout<<"Deleting..."<>number;
//创建对象数组
ArrayOfPoints points(number);
//通过指针访问数组元素的成员
points.Element(0).Move(5,10);
//通过指针访问数组元素的成员
points.Element(1).Move(15,20);
}*null运行结果如下：
Please enter the number of points:2
Default Constructor called.
Default Constructor called.
Deleting...
Destructor called.
Destructor called.*动态创建多维数组动态创建多维数组 new 类型名T[下标表达式1][下标表达式2]…；
如果内存申请成功，new运算返回一个指向新分配内存首地址的指针，是一个T类型的数组，数组元素的个数为除最左边一维外各维下标表达式的乘积。例如：
char (*fp)[3];
fp = new char[2][3]; 动态存储分配nullchar (*fp)[3];fpfp+1*例6-18动态创建多维数组例6-18动态创建多维数组#include
using namespace std;
int main()
{ float (*cp)[9][8];
int i,j,k;
cp = new float[8][9][8];
for (i=0; i<8; i++)
for (j=0; j<9; j++)
for (k=0; k<9; k++)
*(*(*(cp+i)+j)+k)=i*100+j*10+k;
//通过指针访问数组元素 动态存储分配null for (i=0; i<8; i++)
{ for (j=0; j<9; j++)
{ for (k=0; k<8; k++)
//将指针cp作为数组名使用，
//通过数组名和下标访问数组元素
cout< 和 动态存储分配动态内存释放函数动态内存释放函数void free( void *memblock );
参数memblock：指针，指向需释放的内存。
返回值：无
头文件： 和 动态存储分配浅拷贝与深拷贝浅拷贝与深拷贝浅拷贝
实现对象间数据元素的一一对应复制。
深拷贝
当被复制的对象数据成员是指针类型时，不是复制该指针成员本身，而是将指针所指的对象进行复制。浅拷贝与深拷贝例6-20对象的浅拷贝例6-20对象的浅拷贝#include
using namespace std;
class Point
{ //类的声明同例6-16
//……
};
class ArrayOfPoints
{
//类的声明同例6-18
//……
};浅拷贝与深拷贝nullint main()
{ int number;
cin>>number;
ArrayOfPoints pointsArray1(number); pointsArray1.Element(0).Move(5,10); pointsArray1.Element(1).Move(15,20);
ArrayOfPoints pointsArray2(pointsArray1);
cout<<"Copy of pointsArray1:"<
using namespace std;
class Point
{ //类的声明同例6-16 …… };
class ArrayOfPoints
{ public:
ArrayOfPoints(ArrayOfPoints& pointsArray);
//其他成员同例6-18
};浅拷贝与深拷贝nullArrayOfPoints ::ArrayOfPoints
(ArrayOfPoints& pointsArray)
{ numberOfPoints
=pointsArray.numberOfPoint
浙公网安备 33021202002483