c++指针

11 指针和引用
11.1 指针
指针是一个变量，其值为另一个变量的地址。即内存位置的直接地址。
声明的一般形式：

数据类型是指针变量所指向的变量的数据类型，*表示其后的变量为指针变量
数据类型 *指针变量名;
int *ip; //整型的指针
double *dp; //double 型的指针
float *fp; //浮点型的指针
char *ch; //字符型的指针
1
2
3
4
5
指针变量的初始化：

&是取地址运算符，&变量名表示变量的地址。
变量的数据类型必须于指针变量的数据类型一致。
为了安全起见，有时会把指针初始化为空指针（NULL或0）
数据类型 *指针变量名 = &变量名;
*指针变量名 = &变量名;
int a;
int *p = &a;
int *p2;
p2 = &a;
1
2
3
4
5
6
指针变量的引用：

& 取地址符 * 指针运算符（间接运算符），其后是指针变量，表示该指针变量所指向的变量。
& *的优先级是相同的，结合方式都是自左向右。比如 &*p等价于&(*p)。
int x = 3;
int y;
int *p;
p = &x;
y = *p;//y = a
1
2
3
4
5
指针运算（地址运算）

算术运算（移动指针运算）：加减，自增自减。
p+n运算得到的地址是p+n*sizeof(数据类型)。
两个相同数据类型的指针可以进行加减运算，一般用于数组的操作中。
关系运算：指针指向同一串连续存储单元才有意义，比如数组。与0比较，判断是不是空指针。
赋值运算：变量地址赋值给指针变量，数组元素地址赋值给指针变量，指针变量赋值给其他指针变量。
int arr[10],len;
int *p1 = &arr[2],*p2 = &arr[5];
len = p2-p1;//arr[2] 和arr[5]之间的元素个数 3
1
2
3
new和delete运算符

new-为变量分配内存空间；
可以通过判断new返回的指针的值，判断空间是否分配成功。
delete-释放空间
指针变量 = new 数据类型(初值);
delete 指针变量;
delete[] 指针变量;//释放为多个变量分配的地址
int *ip;
ip= new int(1);
delete ip;
int *ip;
ip= new int[10];
for (int i = 0; i < 10;i++)
{
ip[i] = i;
}
delete[] ip;
int a[3][4] = {0};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
指针与数组

数组名是数组的首地址，eg:arr为arr[0]的地址。
访问数组元素：arr[i]，(arr+i)，(p+i)，p[i]
二维数组：arr+i == &arr[i]，arr[i] == &arr[i][0] ，*(arr[i]+j) == arr[i][j]
指针访问二维数组：指向二维数组元素，指向一维数组
数组指针：数据类型 (*指针变量名) [m]
int arr[10];
int *p1 = arr;// *p1 = &arr[0];
int a[3][5] = { 0 };
int(*ap)[5];
ap = a;
ap+1;//表示下一个一维数组
1
2
3
4
5
6
指针与字符串

字符串数组名：char ch[] = “heiren”;char *p = ch;
字符串：char *p = “heiren”;
指针赋值运算：char * p;p = “Heiren”;
指针与函数，指针可以作为函数的参数，也可以作为函数的返回值。
11.2 引用
引用可以看做是数据的一个别名，通过这个别名和原来的名字都能够找到这份数据，类似于window中的快捷方式。

引用不占内存空间，必须在定义的同时初始化，且不能再引用其他数据。
引用在定义时需要添加&，在使用时不能添加&，使用时添加&表示取地址
引用型变量声明：数据类型 &引用名 = 变量名;
int a;
int &b = a;//a和b表示相同的变量，具有相同的地址。
1
2
引用可以作为函数参数，也可以作为函数返回值。

void swap(int &r1, int &r2) {
int temp = r1;
r1 = r2;
r2 = temp;
}
int &add1(int &r) {
r += 1;
return r;
}
int main()
{
int a = 12;
int b = add1(a);
cout << a << " "<<b << endl;//13 13
return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
将引用作为函数返回值时不能返回局部数据的引用，因为当函数调用完成后局部数据就会被销毁。
函数在栈上运行，函数掉用完，后面的函数调用会覆盖之前函数的局部数据。

int &add1(int &r) {
r += 1;
int res = r;
return res;
}
void test()
{
int xx = 123;
int yy = 66;
}
int main()
{
int a = 12;
int &b = add1(a);
int &c = add1(a);
test();//函数调用，覆盖之前函数的局部数据
cout << a << " “<<b <<” "<< c<<endl;//14 -858993460 -858993460
return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
12 自定义数据类型
12.1 结构体
结构体可以包含不同数据类型的结构。
定义结构体的一般形式

struct 结构体类型名
{
成员类型1 成员名1;
成员类型2 成员名2;
… …
成员类型n 成员名n;
};
1
2
3
4
5
6
7
结构体变量名的定义和初始化：

//定义结构体同时声明结构体变量名
struct 结构体类型名
{
成员类型1 成员名1;
成员类型2 成员名2;
… …
成员类型n 成员名n;
}变量名1,变量名2,…变量名n;
//先定义结构体
[struct] 结构体类型名 变量名;
//直接定义
struct
{
成员类型1 成员名1;
成员类型2 成员名2;
… …
成员类型n 成员名n;
}变量名1,变量名2,…变量名n;
struct person
{
int year;
int age;
string name;
}p1 = {2019,24,“heiren”}, p1 = { 2020,24,“heiren” };
struct person
{
int year;
int age;
string name;
};
struct person p1 = { 2019,24,“heiren” }, p1 = { 2020,24,“heiren” };
struct
{
int year;
int age;
string name;
}p1 = {2019,24,“heiren”}, p1 = { 2020,24,“heiren” };
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
结构体变量的使用：

具有相同类型的结构体变量可以进行赋值运算，但是不能输入输出
对结构体变量的成员引用：结构体变量名.成员名
指向结构体的指针变量引用格式：指针变量名->成员名;
结构体数组的定义，初始化和使用与结构体变量、基本类型数组相似
struct person
{
int year;
int age;
string name;
}p[2] ={ {2019,24,“heiren”}, { 2020,24,“heiren” }};//可以不指定数组元素个数
p[1].age;
1
2
3
4
5
6
7
结构体作为函数传递有三种：值传递，引用传递，指针传递

12.2 结构体大小和字节对齐
现代计算机中内存空间都是按照byte划分的，从理论上讲似乎对任何类型的变量的访问可以从任何地址开始，但实际情况是在访问特定类型变量的时候经常在特 定的内存地址访问，这就需要各种类型数据按照一定的规则在空间上排列，而不是顺序的一个接一个的排放，这就是对齐.
为什么需要字节对齐？各个硬件平台对存储空间的处理上有很大的不同。一些平台对某些特定类型的数据只能从某些特定地址开始存取。比如有些平台每次读都是从偶地址开始，如果一个int型（假设为32位系统）如果存放在偶地址开始的地方，那么一个读周期就可以读出这32bit，而如果存放在奇地址开始的地方，就需要2个读周期，并对两次读出的结果的高低字节进行拼凑才能得到该32bit数据。
三个个概念：

自身对齐值：数据类型本身的对齐值，结构体或类的的自身对齐值是其成员中最大的那个值，例如char类型的自身对齐值是1，short类型是2；
指定对齐值：编译器或程序员指定的对齐值，32位单片机的指定对齐值默认是4；
有效对齐值：自身对齐值和指定对齐值中较小的那个。
字节对齐的三个准则
结构体变量的首地址能够被其有效对齐值的大小所整除
结构体的总大小为结构体有效对齐值的整数倍。
结构体每个成员相对于结构体首地址的偏移量都是有效对齐值的整数倍。
可以通过#pragma pack(n)来设定变量以n字节对齐方式
举个例子
//指定对齐值=8
struct st
{
// 空结构体大小1
char c1;//1
char c2;//2
int i1;//8 int 起始地址按照字节对齐的原理应该是它长度4的整数倍
char c3;//12
short s4;//12 short 起始地址按照字节对齐的原理应该是它长度2的整数倍 12 + 2 = 12
double d;//24 double 起始地址按照字节对齐的原理应该是它长度8的整数倍 12->16 + 8 = 24
char c4;//32 24 + 4 = 28 结构体的总大小为8的整数倍 28->32
int i2;//32 28+4 = 32
int i3;//40
short s5;//40
};
cout << sizeof(st) << endl;//40
//指定对齐值=4
#pragma pack(4)
struct st
{
//1 空结构体大小1
char c1;//1
char c2;//2
int i1;//8
char c3;//12
short s4;//12
double d;//20
char c4;//24
int i2;//28
int i3;//32
short s5;//36
}s;
cout << sizeof(st) << endl;//36
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
字节对齐

12.3 公用体(union)
几个不同的变量共享同一个地址开始的内存空间。

成员类型可以是基本数据类型，也可以是构造数据类型。
公用体变量初始化时，只能对第一个成员赋值。
公用体变量所占的内存长度等于最长的成员长度。
公用体变量在一个时刻只能一个成员发挥作用，赋值时，成员之间会互相覆盖，最后一次被赋值的成员起作用。
定义
union 共同体类型名
{
成员类型1 成员名1;
成员类型2 成员名2;
… …
成员类型n 成员名n;
};
1
2
3
4
5
6
7
初始化

union data
{
int i;
float f;
char c;
}x = {123};
union data
{
float f;
int i;
char c;
};
data x = {12.3};
union
{
char c;
int i;
float f;
}x = {’y‘};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
引用

共同体变量名.成员名;
union data
{
int i;
float f;
char c;
}x = {12};
int main()
{
cout << x.i << " " << x.f << " " << x.c << endl;//12 1.68156e-44
x.c = ‘c’;
cout << x.i <<" "<< x.f << " " << x.c << endl;//99 1.38729e-43 c
return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
12.4 枚举(enum)和typedef声明
枚举已经在前面的章节介绍过，这里就不在赘述了。
typedef-为已存在的数据类型定义一个新的类型名称，不能定义变量。
typedef声明格式：typedef 类型名称 类型标识符;

typedef char *CP;
typedef int INTEGER;
1
2
13 面向对象
13.1 类
类也是一种数据类型。
类的声明：

class 类名
{
public:
公有数据成员;
公有成员函数;
private:
私有数据成员;
私有成员函数;
protected:
保护数据成员;
保护成员函数;
};
1
2
3
4
5
6
7
8
9
10
11
12
成员函数的定义：类内，类外，类外内联函数

//类外
返回类型 类名:成员函数名(参数列表)
{
函数体;
}
//内联函数：类外
inline 返回类型 类名:成员函数名(参数列表)
{
函数体;
}
1
2
3
4
5
6
7
8
9
10
内联函数的代码会直接嵌入到主调函数中，可以节省调用时间，如果成员函数在类内定义，自动为内联函数。

13.2 类成员的访问权限以及类的封装
和Java、C#不同的是，C++中public、private、protected只能修饰类的成员，不能修饰类，C++中的类没有共有私有之分
类内部没有访问权限的限制，都可以互相访问。
在C++中用class定义的类中，其成员的默认存取权限是private。
类外 派生类 类内
public Y Y Y
protected N Y Y
private N N Y
13.3 对象
//1.声明类同时定义对象
class 类名
{
类体;
}对象名列表;
//2.先声明类，再定义对象
类名 对象名(参数列表);//参数列表为空时，()可以不写
//3. 不出现类名，直接定义对象
class
{
类体;
}对象名列表;
//4.在堆上创建对象
Person p(123, “yar”);//在栈上创建对象
Person *pp = new Person(234,“yar”);//在堆上创建对象
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
注：不可以在定义类的同时对其数据成员进行初始化，因为类不是一个实体，不合法但是能编译运行
对象成员的引用：对象名.数据成员名 或者 对象名.成员函数名(参数列表)

13.4 构造函数
是一种特殊的成员函数，主要功能是为对象分配存储空间，以及为类成员变量赋初值

构造函数名必须与类名相同
没有任何返回值和返回类型
创建对象自动调用，不需要用户来调用，且只掉用一次
类没有定义任何构造函数，编译系统会自动为这个类生成一个默认的无参构造函数
构造函数定义
//1.类中定义 2.类中声明，类外定义
[类名::]构造函数名(参数列表)
{
函数体
}
1
2
3
4
5
创建对象

类名 对象名(参数列表);//参数列表为空时，()可以不写
1
带默认参数的构造函数

class Person
{
public:
Person(int = 0,string = “张三”);
void show();
private:
int age;
string name;
};
Person::Person(int a, string s)
{
cout<<a<<" "<<s<<endl;
age = a;
name = s;
}
void Person::show()
{
cout << “age=”<<age << endl;
cout << “name=” <<name << endl;
}
int main()
{
Person p; //0 张三
Person p2(12);//12 张三
Person p3(123, “yar”);//123 yar
return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
带参数初始化表的构造函数

类名::构造函数名(参数列表):参数初始化表
{
函数体;
}
参数初始化列表的一般形式：
参数名1(初值1),参数名2(初值2),…,参数名n(初值n)
class Person
{
public:
Person(int = 0,string = “张三”);
void show();
private:
int age;
string name;
};
Person::Person(int a, string s):age(a),name(s)
{
cout << a << " " << s << endl;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
构造函数重载：构造函数名字相同，参数个数和参数类型不一样。

class Person
{
public:
Person();
Person(int = 0,string = “张三”);
Person(double,string);
void show();
private:
int age;
double height;
string name;
};
…
1
2
3
4
5
6
7
8
9
10
11
12
13
拷贝构造函数

类名::类名(类名&对象名)
{
函数体;
}
class Person
{
public:
Person(Person &p);//声明拷贝构造函数
Person(int = 0,string = “张三”);
void show();
private:
int age;
string name;
};
Person::Person(Person &p)//定义拷贝构造函数
{
cout << “拷贝构造函数” << endl;
age = 0;
name = “ABC”;
}
Person::Person(int a, string s):age(a),name(s)
{
cout << a << " " << s << endl;
}
int main()
{
Person p(123, “yar”);
Person p2§;
p2.show();
return 0;
}
//输出
123 yar
拷贝构造函数
age=0
name=ABC
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
13.5 析构函数
是一种特殊的成员函数，当对象的生命周期结束时，用来释放分配给对象的内存空间爱你，并做一些清理的工作。

析构函数名与类名必须相同。
析构函数名前面必须加一个波浪号~。
没有参数，没有返回值，不能重载。
一个类中只能有一个析构函数。
没有定义析构函数，编译系统会自动为和这个类生成一个默认的析构函数。
析构函数的定义：
//1.类中定义 2.类中声明，类外定义
[类名::]~析构函数名()
{
函数体;
}
1
2
3
4
5
13.6 对象指针
对象指针的声明和使用

类名 对象指针名;
对象指针 = &对象名;
//访问对象成员
对象指针->数据成员名
对象指针->成员函数名(参数列表)
Person p(123, “yar”);
Person pp = &p;
Person* pp2 = new Person(234,“yar”)
pp->show();
1
2
3
4
5
6
7
8
9
指向对象成员的指针

数据成员类型 *指针变量名 = &对象名.数据成员名;
函数类型 (类名::*指针变量名)(参数列表);
指针变量名=&类名::成员函数名;
(对象名.*指针变量名)(参数列表);
Person p(123, “yar”);
void(Person::*pfun)();
pfun = &Person::show;
(p.*pfun)();
1
2
3
4
5
6
7
8
this指针
每个成员函数都有一个特殊的指针this，它始终指向当前被调用的成员函数操作的对象

class Person
{
public:
Person(int = 0,string = “张三”);
void show();
private:
int age;
string name;
};
Person::Person(int a, string s):age(a),name(s)
{
cout << a << " " << s << endl;
}
void Person::show()
{
cout << “age=”<age << endl;
cout << “name=” <name << endl;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
13.7 静态成员
以关键字static开头的成员为静态成员，多个类共享。

static 成员变量属于类，不属于某个具体的对象
静态成员函数只能访问类中静态数据成员
静态数据成员
//类内声明，类外定义
class xxx
{
static 数据类型 静态数据成员名;
}
数据类型 类名::静态数据成员名=初值
//访问
类名::静态数据成员名;
对象名.静态数据成员名;
对象指针名->静态数据成员名;
1
2
3
4
5
6
7
8
9
10
静态成员函数

//类内声明，类外定义
class xxx
{
static 返回值类型 静态成员函数名(参数列表);
}
返回值类型 类名::静态成员函数名(参数列表)
{
函数体;
}
//访问
类名::静态成员函数名(参数列表);
对象名.静态成员函数名(参数列表);
对象指针名->静态成员函数名(参数列表);
1
2
3
4
5
6
7
8
9
10
11
12
13
13.8 友元
借助友元(friend)，可以使得其他类中得成员函数以及全局范围内得函数访问当前类得private成员。
友元函数

友元函数不是类的成员函数，所以没有this指针，必须通过参数传递对象。
友元函数中不能直接引用对象成员的名字，只能通过形参传递进来的对象或对象指针来引用该对象的成员。
//1.将非成员函数声明为友元函数
class Person
{
public:
Person(int = 0,string = “张三”);
friend void show(Person *pper);//将show声明为友元函数
private:
int age;
string name;
};
Person::Person(int a, string s):age(a),name(s)
{
cout << a << " " << s << endl;
}
void show(Person *pper)
{
cout << “age=”<< pper->age << endl;
cout << “name=” << pper->name << endl;
}
int main()
{;
Person *pp = new Person(234,“yar”);
show(pp);
system(“pause”);
return 0;
}
//2.将其他类的成员函数声明为友元函数
//person中的成员函数可以访问MobilePhone中的私有成员变量
class MobilePhone;//提前声明
//声明Person类
class Person
{
public:
Person(int = 0,string = “张三”);
void show(MobilePhone *mp);
private:
int age;
string name;
};
//声明MobilePhone类
class MobilePhone
{
public:
MobilePhone();
friend void Person::show(MobilePhone *mp);
private:
int year;
int memory;
string name;
};
MobilePhone::MobilePhone()
{
year = 1;
memory = 4;
name = “iphone 6s”;
}
Person::Person(int a, string s):age(a),name(s)
{
cout << a << " " << s << endl;
}
void Person::show(MobilePhone *mp)
{
cout << mp->year << "年 " << mp->memory << "G " << mp->name << endl;
}
int main()
{
Person *pp = new Person(234,“yar”);
MobilePhone *mp = new MobilePhone;
pp->show(mp);
system(“pause”);
return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
友元类
当一个类为另一个类的友元时，称这个类为友元类。 友元类的所有成员函数都是另一个类中的友元成员。
语法形式：friend [class] 友元类名

类之间的友元关系不能传递
类之间的友元关系是单向的
友元关系不能被继承
class HardDisk
{
public:
HardDisk();
friend class Computer;
private:
int capacity;
int speed;
string brand;
};
HardDisk::HardDisk():capacity(128),speed(0),brand(“三星”){
}
class Computer
{
public:
Computer(HardDisk hd);
void start();
private:
string userName;
string name;
int ram;
string cpu;
int osType;
HardDisk hardDisk;

};
Computer::Computer(HardDisk hd):userName(“yar”),name(“YAR-PC”),ram(16),cpu(“i7-4710”),osType(64)
{
cout << “正在创建computer…” << endl;
this->hardDisk = hd;
this->hardDisk.speed = 5400;
cout << "硬盘转动…speed = " << this->hardDisk.speed << “转/分钟” << endl;

}
void Computer::start()
{

cout << hardDisk.brand << " " << hardDisk.capacity << "G" << hardDisk.speed << "转/分钟" << endl;
cout << "笔记本开始运行..." << endl;

}
int main()
{
HardDisk hd;
Computer cp(hd);
cp.start();
system(“pause”);
return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
13.9 类(class)与结构体(struct)的区别
引入C语言的结构体，是为了保证和c程序的兼容性。
c语言中的结构体不允许定义函数成员，且没有访问控制权限的属性。
c++为结构体引入了成员函数，访问控制权限，继承，多态等面向对象特性。
c语言中，空结构体的大小为0，而C++中空结构体大小为1。
class中成员默认是private,struct中的成员默认是public。
class继承默认是private继承，而struct继承默认是public继承。
class可以使用模版，而struct不能。
举个例子：
//结构体默认权限为public
struct person
{
void show();
string name;
int age;
};
int main()
{
person p;
p.name = “heiren”;
p.age = 666;
p.show();
cout <<“name=”<< p.name <<" age="<< p.age << endl;
system(“pause”);
return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
将struct改为class，运行报错。

14 继承和派生
14.1 继承和派生概述
继承就是再一个已有类的基础上建立一个新类，已有的类称基类或父类，新建立的类称为派生类和子类；派生和继承是一个概念，角度不同而已，继承是儿子继承父亲的产业，派生是父亲把产业传承给儿子。

一个基类可以派生出多个派生类，一个派生类可以继承多个基类
派生类的声明：
//继承方式为可选项，默认为private，还有public,protected
class 派生类名：[继承方式]基类名
{
派生类新增加的成员声明;
};
1
2
3
4
5
继承方式：

public-基类的public成员和protected成员的访问属性保持不变，私有成员不可见。
private-基类的public成员和protected成员成为private成员,只能被派生类的成员函数直接访问，私有成员不可见。
protected-基类的public成员和protected成员成为protected成员,只能被派生类的成员函数直接访问，私有成员不可见。
继承方式/基类成员 public成员 protected成员 private成员
public public protected 不可见
protected protected protected 不可见
private private private 不可见
利用using关键字可以改变基类成员再派生类中的访问权限；using只能修改基类中public和protected成员的访问权限。
class Base
{
public:
void show();
protected:
int aa;
double dd;
};
void Base::show(){
}
class Person:public Base
{
public:
using Base::aa;//将基类的protected成员变成public
using Base::dd;//将基类的protected成员变成public
private:
using Base::show;//将基类的public成员变成private
string name;
};
int main()
{
Person *p = new Person();
p->aa = 12;
p->dd = 12.3;
p->show();//出错
delete p;
return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
派生类的构造函数和析构函数

先执行基类的构造函数，随后执行派生类的构造函数
先执行派生类的析构函数，再执行基类的析构函数。
派生类的构造函数：派生类名(总参数列表)：基类名(基类参数列表),子对象名1(参数列表){构造函数体;}
class Base
{
public:
Base(int, double);
~Base();
private:
int aa;
double dd;
};
Base::Base(int a, double d) :aa(a), dd(d)
{
cout << “Base Class 构造函数!!!” << endl;
}
Base::~Base()
{
cout << “Base Class 析构函数!!!” << endl;
}
class Person:public Base
{
public:
Person(int,double,string);
~Person();
private:
string name;
};
Person::Person(int a,double d,string str):Base(a,d),name(str)
{
cout << “Person Class 构造函数!!!” << endl;
}
Person::~Person()
{
cout << “Person Class 析构函数!!!” << endl;
}
int main()
{
cout << “创建Person对象…” << endl;
Person *p = new Person(1,2,“yar”);
cout << “删除Person对象…” << endl;
delete p;
system(“pause”);
return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42