程序设计与算法语言拷贝构造 C/C++ Programming and Algorithms Copy Constructor Dongke Sun ( 孙东科 ) 东南大学机械工程学院 School of Mechanical Engineering South

Size: px

Start display at page:

Download "程序设计与算法语言拷贝构造 C/C++ Programming and Algorithms Copy Constructor Dongke Sun ( 孙东科 ) 东南大学机械工程学院 School of Mechanical Engineering South"

符封苗
5 years ago
Views:

1 程序设计与算法语言拷贝构造 C/C++ Programming and Algorithms Copy Constructor Dongke Sun ( 孙东科 ) dksun@seu.edu.cn 东南大学机械工程学院 School of Mechanical Engineering Southeast University Spring semester, 2019

2 视 C++ 为一个语言联邦 Scott Meyers Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

3 Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

4 提纲 1 拷贝构造函数 2 构造函数与类型转换 3 构造函数与对象成员 4 对象成员的初始化 5 总结与思考 Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

5 提纲拷贝构造函数 1 拷贝构造函数 2 构造函数与类型转换 3 构造函数与对象成员 4 对象成员的初始化 5 总结与思考 Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

6 拷贝构造函数为什么需要拷贝构造函数尝试分析下面程序出错的原因 1 class Student 2 { 3 int Age; 4 public: 5 char *Name; // 注意 : 指针 6 Student(char *name, int age) 7 { 8 if(name) // 动态申请空间 9 { 10 Name = new char [ strlen(name)+1]; 11 strcpy(name, name); 12 } 13 else Name= NULL; 14 } 15 ~Student( ) // 释放空间 16 { 17 if(name) delete [] Name; 18 } 19 }; 20 Student change(char *name, int age ) 21 { 22 Student c(name,age); 23 return c; 24 } 25 int display(student b) 26 { 27 cout << b.name << endl; 28 return 1; 29 } 25 int main() 26 { 27 Student a("michael", 18); 28 Student b=a; // 出错! 29 int flag=display(a); // 出错! 30 b=change("annie",20);// 出错! 31 return 0; 32 } Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

7 拷贝构造函数为什么需要拷贝构造函数前提条件尝试分析下面程序出错的原因类中有数据成员使用 new 动态地申请了内存空间 1 class Student 2 { 3 int Age; 4 public: 5 char *Name; // 注意 : 指针 6 Student(char *name, int age) 7 { 8 if(name) // 动态申请空间 9 { 10 Name = new char [ strlen(name)+1]; 11 strcpy(name, name); 12 } 13 else Name= NULL; 14 } 15 ~Student( ) // 释放空间 16 { 17 if(name) delete [] Name; 18 } 19 }; 20 Student change(char *name, int age ) 21 { 22 Student c(name,age); 23 return c; 24 } 25 int display(student b) 26 { 27 cout << b.name << endl; 28 return 1; 29 } 25 int main() 26 { 27 Student a("michael", 18); 28 Student b=a; // 出错! 29 int flag=display(a); // 出错! 30 b=change("annie",20);// 出错! 31 return 0; 32 } Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

8 拷贝构造函数为什么需要拷贝构造函数前提条件尝试分析下面程序出错的原因类中有数据成员使用 new 动态地申请了内存空间 1 class Student 20 Student change(char *name, int age 2 三处 { 出错对应于 ) 3 int Age; 21 { 4 public: 类的一个对象初始化另外一个对象 : 赋值初始化 22 Student c(name,age); 5 类的对象作为函数的参数 char *Name; // 注意 : 指针, 以值传递的方式传入 23 return c; 6 Student(char *name, int age) 24 } 7 类的对象作为函数返回值 {, 以值传递的方式返回 25 int display(student b) 8 if(name) // 动态申请空间 26 { 9 { 27 cout << b.name << endl; 10 Name = new char [ 28 return 1; strlen(name)+1]; 29 } 11 strcpy(name, name); 12 } 25 int main() 13 else Name= NULL; 26 { 14 } 27 Student a("michael", 18); 15 ~Student( ) // 释放空间 28 Student b=a; // 出错! 16 { 29 int flag=display(a); // 出错! 17 if(name) delete [] Name; 30 b=change("annie",20);// 出错! 18 } 31 return 0; 19 }; 32 } Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

9 拷贝构造函数拷贝构造函数和缺省拷贝构造函数拷贝 ( 复制 ) 构造函数是一种特殊的构造函数它由编译器调用来完成一些基于同一类的其他对象的构建及初始化其一般格式为 1 ClassName :: ClassName( [const] ClassName & Obj ) // 注意 : 引用 2 { 函数体 <> } 拷贝构造函数唯一的形参必须是该类对象的引用, 一般会加上 const 限制 Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

10 拷贝构造函数拷贝构造函数和缺省拷贝构造函数拷贝 ( 复制 ) 构造函数是一种特殊的构造函数它由编译器调用来完成一些基于同一类的其他对象的构建及初始化其一般格式为 1 ClassName :: ClassName( [const] ClassName & Obj ) // 注意 : 引用 2 { 函数体 <> } 拷贝构造函数唯一的形参必须是该类对象的引用, 一般会加上 const 限制如果不定义拷贝构造函数, 则由编译器自动产生一个默认 ( 缺省 ) 的拷贝构造函数 Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

11 拷贝构造函数拷贝构造函数和缺省拷贝构造函数拷贝 ( 复制 ) 构造函数是一种特殊的构造函数它由编译器调用来完成一些基于同一类的其他对象的构建及初始化其一般格式为 1 ClassName :: ClassName( [const] ClassName & Obj ) // 注意 : 引用 2 { 函数体 <> } 拷贝构造函数唯一的形参必须是该类对象的引用, 一般会加上 const 限制如果不定义拷贝构造函数, 则由编译器自动产生一个默认 ( 缺省 ) 的拷贝构造函数当类中有动态申请的成员空间时, 务必定义一个拷贝构造函数, 用以避免内存异常 Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

12 拷贝构造函数拷贝构造函数和缺省拷贝构造函数拷贝 ( 复制 ) 构造函数是一种特殊的构造函数它由编译器调用来完成一些基于同一类的其他对象的构建及初始化其一般格式为 1 ClassName :: ClassName( [const] ClassName & Obj ) // 注意 : 引用 2 { 函数体 <> } 拷贝构造函数唯一的形参必须是该类对象的引用, 一般会加上 const 限制如果不定义拷贝构造函数, 则由编译器自动产生一个默认 ( 缺省 ) 的拷贝构造函数当类中有动态申请的成员空间时, 务必定义一个拷贝构造函数, 用以避免内存异常定义拷贝构造函数的时机 Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

13 拷贝构造函数拷贝构造函数和缺省拷贝构造函数拷贝 ( 复制 ) 构造函数是一种特殊的构造函数它由编译器调用来完成一些基于同一类的其他对象的构建及初始化其一般格式为 1 ClassName :: ClassName( [const] ClassName & Obj ) // 注意 : 引用 2 { 函数体 <> } 拷贝构造函数唯一的形参必须是该类对象的引用, 一般会加上 const 限制如果不定义拷贝构造函数, 则由编译器自动产生一个默认 ( 缺省 ) 的拷贝构造函数当类中有动态申请的成员空间时, 务必定义一个拷贝构造函数, 用以避免内存异常定义拷贝构造函数的时机当只需要拷贝同一个类不同对象的部分数据成员时, 以及 Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

14 拷贝构造函数拷贝构造函数和缺省拷贝构造函数拷贝 ( 复制 ) 构造函数是一种特殊的构造函数它由编译器调用来完成一些基于同一类的其他对象的构建及初始化其一般格式为 1 ClassName :: ClassName( [const] ClassName & Obj ) // 注意 : 引用 2 { 函数体 <> } 拷贝构造函数唯一的形参必须是该类对象的引用, 一般会加上 const 限制如果不定义拷贝构造函数, 则由编译器自动产生一个默认 ( 缺省 ) 的拷贝构造函数当类中有动态申请的成员空间时, 务必定义一个拷贝构造函数, 用以避免内存异常定义拷贝构造函数的时机当只需要拷贝同一个类不同对象的部分数据成员时, 以及当类中某个数据成员是动态地申请内存并赋初值时 Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

15 拷贝构造函数拷贝构造函数和缺省拷贝构造函数拷贝 ( 复制 ) 构造函数是一种特殊的构造函数它由编译器调用来完成一些基于同一类的其他对象的构建及初始化其一般格式为 1 ClassName :: ClassName( [const] ClassName & Obj ) // 注意 : 引用 2 { 函数体 <> } 拷贝构造函数唯一的形参必须是该类对象的引用, 一般会加上 const 限制如果不定义拷贝构造函数, 则由编译器自动产生一个默认 ( 缺省 ) 的拷贝构造函数当类中有动态申请的成员空间时, 务必定义一个拷贝构造函数, 用以避免内存异常定义拷贝构造函数的时机当只需要拷贝同一个类不同对象的部分数据成员时, 以及当类中某个数据成员是动态地申请内存并赋初值时必须显式地定义一个完成拷贝功能的构造函数, 以实现数据成员的复制 ; 还应 Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

16 拷贝构造函数拷贝构造函数和缺省拷贝构造函数拷贝 ( 复制 ) 构造函数是一种特殊的构造函数它由编译器调用来完成一些基于同一类的其他对象的构建及初始化其一般格式为 1 ClassName :: ClassName( [const] ClassName & Obj ) // 注意 : 引用 2 { 函数体 <> } 拷贝构造函数唯一的形参必须是该类对象的引用, 一般会加上 const 限制如果不定义拷贝构造函数, 则由编译器自动产生一个默认 ( 缺省 ) 的拷贝构造函数当类中有动态申请的成员空间时, 务必定义一个拷贝构造函数, 用以避免内存异常定义拷贝构造函数的时机当只需要拷贝同一个类不同对象的部分数据成员时, 以及当类中某个数据成员是动态地申请内存并赋初值时必须显式地定义一个完成拷贝功能的构造函数, 以实现数据成员的复制 ; 还应显式地定义相应的析构函数, 用以撤消动态分配的空间 Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

17 拷贝构造函数拷贝构造函数和缺省拷贝构造函数拷贝构造函数唯一的形参必须是该类对象的引用, 一般会加上 const 限制 1 class A 2 { 3 private: 4 int value; 5 public: 6 A(int n) { value = n; } 7 A(A other) { value = other.value; } 8 void Print() { cout << value << endl; } 9 }; 10 int main(void) 11 { 12 A a = 10; 13 A b = a; 14 b.print(); 15 return 0; 16 } 分析上述代码编译运行结果, 下列说法正确的是 :( ) A. 编译错误 B. 编译成功, 运行时程序崩溃 C. 编译错误, 缺少默认构造函数 D. 编译运行正常, 输出 10 Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

18 拷贝构造函数拷贝构造函数和缺省拷贝构造函数拷贝构造函数唯一的形参必须是该类对象的引用, 一般会加上 const 限制 1 class A 2 { 3 private: 4 int value; 5 public: 6 A(int n) { value = n; } 7 A(A other) { value = other.value; } 8 void Print() { cout << value << endl; } 9 }; 10 int main(void) 11 { 12 A a = 10; 13 A b = a; 14 b.print(); 15 return 0; 16 } 分析上述代码编译运行结果, 下列说法正确的是 :( A ) A. 编译错误 B. 编译成功, 运行时程序崩溃 C. 编译错误, 缺少默认构造函数 D. 编译运行正常, 输出 10 Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

19 拷贝构造函数拷贝构造函数和缺省拷贝构造函数分析拷贝构造函数唯一的形参必须是该类对象的引用, 一般会加上 const 限制拷贝构造函数 A(A other) 传入的参数是类 A 的一个实例由于是传值, 形 1 class A 参传递给实参时会调用拷贝构造函数 2 { 3 如果允许传值 private:, 就会在拷贝构造函数内调用拷贝构造函数, 从而形成永无 4 休止的循环调用并最终导致栈溢出 int value; 5 public: 6 A(int n) { value = n; } 注意 7 A(A other) { value = other.value; } 8 不允许复制构造函数传值参数 void Print() { cout << value, 只能将构造函数修改为引用参数例如 << endl; }, 9 }; 可将传值参数改为常量引用 10 int main(void) :const A & other 11 传指针也是不允许的 {, 只能改为该类对象的引用或常量引用 12 A a = 10; 13 A b = a; 14 b.print(); 15 return 0; 16 } 分析上述代码编译运行结果, 下列说法正确的是 :( A ) A. 编译错误 B. 编译成功, 运行时程序崩溃 C. 编译错误, 缺少默认构造函数 D. 编译运行正常, 输出 10 Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

20 拷贝构造函数拷贝构造函数和缺省拷贝构造函数如果不定义拷贝构造函数, 则由编译器自动产生一个默认 ( 缺省 ) 的拷贝构造函数 1 class Point 2 { 3 int x, y; 4 public: 5 Point(int a=0, int b=0) // 缺省构造函数 6 { x=a; y=b; } 7 8 ~Point( ) // 析构函数 9 {... } 10 void Show( ) 11 {... } 12 int Getx( ) 13 { return x; } 14 int Gety( ) 15 { return y; } 16 }; int main( ) 24 { 25 Point p1(6, 8), p2(4, 7); 26 Point p3(p1); // 调用拷贝构造 27 Point p4=p2; // 调用拷贝构造 28 p1.show( ); 29 p3.show( ); 30 p2.show( ); 31 p4.show( ); 32 return 0; 33 } 尽管没有定义拷贝构造函数, 但在调用时编译器会生成默认的拷贝构造函数 Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

21 拷贝构造函数拷贝构造函数和缺省拷贝构造函数如果不定义拷贝构造函数, 则编译器会自动生成一个默认 ( 缺省 ) 的拷贝构造函数如果用户定义了拷贝构造函数呢? 1 class Point 2 { 3 int x, y; 4 public: 5 Point(int a=0, int b=0) // 默认构造函数 6 { x=a; y=b; } 7 Point(Point &p); // 拷贝构造 8 ~Point( ) // 析构函数 9 {... } 10 void Show( ) 11 {... } 12 int Getx( ) 13 { return x; } 14 int Gety( ) 15 { return y; } 16 }; 17 // 定义拷贝构造函数 18 Point::Point(Point &p) 19 { 20 x=p.x; y=p.y; } 23 int main( ) 24 { 25 Point p1(6, 8), p2(4, 7); 26 Point p3(p1); // 调用拷贝构造 27 Point p4=p2; // 调用拷贝构造 28 p1.show( ); 29 p3.show( ); 30 p2.show( ); 31 p4.show( ); 32 return 0; 33 } Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

22 拷贝构造函数拷贝构造函数和缺省拷贝构造函数如果不定义拷贝构造函数, 则编译器会自动生成一个默认 ( 缺省 ) 的拷贝构造函数如果用户定义了拷贝构造函数呢? 1 class Point 2 { 3 int x, y; 4 public: 5 Point(int a=0, int b=0) // 默认构造函数 6 { x=a; y=b; } 7 Point(Point &p); // 拷贝构造 8 ~Point( ) // 析构函数 9 {... } 10 void Show( ) 11 {... } 12 int Getx( ) 13 { return x; } 14 int Gety( ) 15 { return y; } 16 }; 17 // 定义拷贝构造函数 18 Point::Point(Point &p) 19 { 20 x=p.x; y=p.y; } 23 int main( ) 24 { 25 Point p1(6, 8), p2(4, 7); 26 Point p3(p1); // 调用拷贝构造 27 Point p4=p2; // 调用拷贝构造 28 p1.show( ); 29 p3.show( ); 30 p2.show( ); 31 p4.show( ); 32 return 0; 33 } 此时, 用户定义了拷贝构造函数, 编译器就不再生成默认的拷贝构造函数 Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

23 拷贝构造函数拷贝构造函数和缺省拷贝构造函数分析并写出用户定义和不定义拷贝构造函数两种情况下的程序输出结果 1 class Point 2 { 3 int x, y; 4 public: 5 Point(int a=0, int b=0) { x=a; y=b; } // 缺省构造函数 6 Point(Point &p) // 拷贝构造函数, 删除后呢? 7 { x=p.x; y=p.y; 8 cout<<x<<, <<y<<" Copy-initialization Constructor Called.\n"; } 9 ~Point( ) { cout<<x<<, <<y<<" Destructor Called.\n" ; } 10 void Show( ) { cout<<"point: "<<x<<, <<y<<endl; } 11 int Getx( ) { return x; } int Gety( ) { return y; } 12 }; 13 int main( ) 14 { 15 Point p1(6, 8), p2(4, 7); 16 Point p3(p1); // 调用拷贝构造函数 17 Point p4 = p2; // 调用拷贝构造函数 18 p1.show( ); p3.show( ); p2.show( ); p4.show( ); 19 return 0; 20 } Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

24 拷贝构造函数拷贝构造函数和缺省拷贝构造函数程序运行结果分析并写出用户定义和不定义拷贝构造函数两种情况下的程序输出结果定义拷贝构造函数 6, 1 8class Copy-initialization Point Constructor Called. 2 4, 7{ Copy-initialization Constructor Called. 3 int x, y; Point: 6, 8 4 public: Point: 5 Point(int 6, 8 a=0, int b=0) { x=a; y=b; } // 缺省构造函数 Point: 6 Point(Point 4, 7 &p) // 拷贝构造函数, 删除后呢? 7 Point: { 4, x=p.x; 7 y=p.y; 8 cout<<x<<, <<y<<" Copy-initialization Constructor Called.\n"; } 4, 7 Destructor 9 ~Point( ) Called. { cout<<x<<, <<y<<" Destructor Called.\n" // 撤销 P4 ; } 6, 10 8 Destructor void Show( ) Called. { cout<<"point: "<<x<<, <<y<<endl; // 撤销 P3 } 4, 11 7 Destructor int Getx( ) Called. { return// x; 撤销 } P2 int Gety( ) { return y; } 12 6, 8}; Destructor Called. 13 int main( ) // 撤销 P1 请测试删除拷贝构造函数时以上代码的运行结果 14 { 15 Point p1(6, 8), p2(4, 7); 16 Point p3(p1); // 调用拷贝构造函数 17 Point p4 = p2; // 调用拷贝构造函数 18 p1.show( ); p3.show( ); p2.show( ); p4.show( ); 19 return 0; 20 } Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

25 拷贝构造函数拷贝构造函数和缺省拷贝构造函数程序运行结果分析并写出用户定义和不定义拷贝构造函数两种情况下的程序输出结果定义拷贝构造函数 6, 1 8class Copy-initialization Point Constructor Called. 2 4, 7{ Copy-initialization Constructor Called. 3 int x, y; Point: 程序运行结果 6, 8 4 public: 不定义拷贝构造函数 Point: 5 Point(int 6, a=0, int b=0) { x=a; y=b; } // 缺省构造函数 Point: 6, 8 Point: 6 Point(Point 4, 7 &p) // 拷贝构造函数, 删除后呢? Point: 7 { 6, x=p.x; 8 Point: 4, y=p.y; Point: 8 4, cout<<x<<, <<y<<" Copy-initialization Constructor Called.\n"; 7 } 4, 7 Destructor 9 ~Point( ) Called. { cout<<x<<, <<y<<" Destructor Called.\n" // 撤销 P4 Point: 4, 7 ; } 6, 10 8 Destructor void Show( ) Called. { cout<<"point: "<<x<<, <<y<<endl; // 撤销 P3 } 4, 7 Destructor Called. // 撤销 P4 4, 11 Destructor int Getx( ) Called. { return// x; 撤销 } P2 int Gety( ) { return y; } 6, 12 8}; Destructor Called. // 撤销 P3 6, Destructor Called. // 撤销 P1 4, 13 7intDestructor main( ) Called. // 撤销 P2 请测试删除拷贝构造函数时以上代码的运行结果 14 6, 8{ Destructor Called. // 撤销 P1 15 Point p1(6, 8), p2(4, 7); 16 Point p3(p1); // 调用拷贝构造函数 17 Point p4 = p2; // 调用拷贝构造函数 18 p1.show( ); p3.show( ); p2.show( ); p4.show( ); 19 return 0; 20 } Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

26 拷贝构造函数拷贝构造函数和缺省拷贝构造函数当类中有动态申请空间的成员时, 务必定义一个拷贝构造函数以避免异常 1 class Student 2 { 3 int Age; 4 public: 5 char *Name; // 注意 : 指针 6 Student(char *name, int age) 7 { 8 if(name) // 动态申请空间 9 { 10 Name = new char [ strlen(name)+1]; 11 strcpy(name, name); 12 } 13 else Name= NULL; 14 } 15 ~Student( ) // 释放空间 16 { 17 if(name) delete [] Name; 18 } 19 }; 20 Student change(char *name, int age ) 21 { 22 Student c(name,age); 23 return c; 24 } 25 int display(student b) 26 { 27 cout << b.name << endl; 28 return 1; 29 } 25 int main() 26 { 27 Student a("michael", 18); 28 Student b=a; // 出错! 29 int flag=display(a); // 出错! 30 b=change("annie",20);// 出错! 31 return 0; 32 } Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

27 拷贝构造函数拷贝构造函数和缺省拷贝构造函数解决之道当类中有动态申请空间的成员时, 务必定义一个拷贝构造函数以避免异常在类中显示地 ( 手工 ) 定义一个拷贝构造函数, 用以避免产生内存异常 1 class Student 20 Student change(char *name, int age 2 { ) 3 int Age; 21 { 4 public: 22 Student c(name,age); 5 char *Name; // 注意 : 指针 23 return c; 6 Student(char *name, int age) 24 } 7 { 25 int display(student b) 8 if(name) // 动态申请空间 26 { 9 { 27 cout << b.name << endl; 10 Name = new char [ 28 return 1; strlen(name)+1]; 29 } 11 strcpy(name, name); 12 } 25 int main() 13 else Name= NULL; 26 { 14 } 27 Student a("michael", 18); 15 ~Student( ) // 释放空间 28 Student b=a; // 出错! 16 { 29 int flag=display(a); // 出错! 17 if(name) delete [] Name; 30 b=change("annie",20);// 出错! 18 } 31 return 0; 19 }; 32 } Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

28 拷贝构造函数拷贝构造函数和缺省拷贝构造函数编译器自动提供的拷贝构造函数如下 : 1 Student::Student(const Student &s) 2 { 3 Name = s.name; // 注意 : 地址值直接赋值 4 Age = s.age; 5 } 正确的做法是, 手工定义拷贝构造函数例如 1 Student::Student(const Student &s) 2 { 3 Age = s.age; 4 if(s.name) 5 { 6 Name = new char[strlen(s.name)+1]; //C 7 strcpy(name, s.name); 8 } 9 else 10 Name=NULL; 11 } 请在 CodeBlocks 中测试 StudentCopy.cpp Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

29 拷贝构造函数拷贝构造函数和缺省拷贝构造函数阅读并分析出错原因程序代码如下 1 class Student { 2 char *Name; // 姓名, 用指针实现 3 int Age; // 年龄 4 public: 5 Student(char *name, int age) { // 构造函数 6 Age=age; 7 if(name) // 在构造函数中, 需动态申请空间 8 { Name=new char[strlen(name)+1]; strcpy(name, name); } 9 else 10 { Name=NULL; } 11 } 12 // 因在构造函数中动态申请了内存空间, 则在析构函数中, 需释放内存空间 13 ~Student( ) { if(name) delete [ ] Name; } 14 void Show( ) { cout << Name <<, << Age << endl; } 15 }; 16 int main( ) { 17 Student a("george", 20); 18 Student b = a; // 19 return 0; 20 } Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

30 拷贝构造函数拷贝构造函数和缺省拷贝构造函数阅读并分析出错原因程序代码如下 1 class Student { 2 char *Name; // 姓名, 用指针实现 3 int Age; // 年龄 4 public: 5 Student(char *name, int age) { // 构造函数 6 Age=age; 7 if(name) // 在构造函数中, 需动态申请空间 8 { Name=new char[strlen(name)+1]; strcpy(name, name); } 9 else 10 { Name=NULL; } 11 } 12 // 因在构造函数中动态申请了内存空间, 则在析构函数中, 需释放内存空间 13 ~Student( ) { if(name) delete [ ] Name; } 14 void Show( ) { cout << Name <<, << Age << endl; } 15 }; 16 int main( ) { 17 Student a("george", 20); 18 Student b = a; // 错误 : 执行拷贝初始化, 但没有定义类的拷贝构造函数 19 return 0; 20 } Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

31 拷贝构造函数拷贝构造函数的调用时机当利用同一个类的其他对象产生新对象时, 系统自动调用拷贝构造函数那么, 产生新对象发生在什么时候? 1 明确表示由一个对象初始化另一个对象时例如 1 Point p3(p1); // A 调用拷贝构造函数 2 Point p4 = p2; // B 调用拷贝构造函数 2 当用对象作为函数参数时, 用实参对象初始化形参对象时 ; 以及 3 当函数返回对象时, 用返回值对象初始化内存临时对象时例如 1 Point move(point p, int xoffset, int yoffset) // Point p=p1 值传递 ; 2 { 3...; return t; // 返回时创建临时对象临时对象 _t (t 的副本 ) 4 } 请在 CodeBlocks 中运行 PointTest.cpp, 测试用对象做函数参数, 以及用对象做函数返回值两种情况下拷贝构造函数的用法注意观察拷贝构造函数的调用时机 Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

32 拷贝构造函数拷贝构造函数的调用时机理解拷贝构造函数的用法, 注意拷贝构造函数的调用时机 1 #include <iostream> 2 #include "./Point.h" 3 using namespace std; 4 5 // 注意 :move 是普通函数, 不是类的成员函数 6 Point move(point p, int xoffset, int yoffset) // A Point p=p1 参数传递 7 { 8 int x = p.getx( )+xoffset; 9 int y = p.gety( )+yoffset; 10 Point t(x, y); 11 return t; // B 12 } 13 int main( ) 14 { 15 Point p1(6, 8), p2; 16 p2 = move(p1, 2, 4); // A, B 对象为函数参数, 用实参对象初始化形参对象 return 0; 19 } 此程序运行结果是? Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

33 拷贝构造函数拷贝构造函数的调用时机理解拷贝构造函数的用法, 注意拷贝构造函数的调用时机 1 #include <iostream> 2 #include "./Point.h" 3 using namespace std; 4 5 // 注意 :move 是普通函数, 不是类的成员函数 6 Point move(point p, int xoffset, int yoffset) // A Point p=p1 参数传递 7 { 8 int x = p.getx( )+xoffset; 9 int y = p.gety( )+yoffset; 10 Point t(x, y); 11 return t; // B 返回时创建临时对象 _t 调用拷贝构造; 先后撤销 t p 和 _t 12 } 13 int main( ) 14 { 15 Point p1(6, 8), p2; 16 p2 = move(p1, 2, 4); // A, B 对象为函数参数, 用实参对象初始化形参对象 return 0; 19 } 此程序运行结果是? Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

34 程序运行结果 VS2017 拷贝构造函数拷贝构造函数的调用时机 6, 8 Copy-initialization Constructor Called. // A 8, 12 Copy-initialization Constructor Called. // B 创建临时对象 8, 理解拷贝构造函数的用法 12 Destructor Called., 注意拷贝构造函数的调用时机 // 撤消对象 t 6, 8 Destructor Called. // 撤消对象 p 1 #include <iostream> 8, 12 2 #include Destructor "./Point.h" Called. // 撤消临时对象 8, 3 12 using Destructor namespace std; Called. // 撤消对象 p2 6, 4 8 Destructor Called. // 撤消对象 p1 5 // 注意 :move 是普通函数, 不是类的成员函数 6 Point move(point p, int xoffset, int yoffset) // A Point p=p1 参数传递 7 { 8 int x = p.getx( )+xoffset; 9 int y = p.gety( )+yoffset; 10 Point t(x, y); 11 return t; // B 返回时创建临时对象 _t 调用拷贝构造; 先后撤销 t p 和 _t 12 } 13 int main( ) 14 { 15 Point p1(6, 8), p2; 16 p2 = move(p1, 2, 4); // A, B 对象为函数参数, 用实参对象初始化形参对象 return 0; 19 } 此程序运行结果是? Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

35 程序运行结果 VS2017 拷贝构造函数拷贝构造函数的调用时机 6, 8 Copy-initialization Constructor Called. // A 8, 12 Copy-initialization Constructor Called. // B 创建临时对象 8, 理解拷贝构造函数的用法 12 Destructor Called., 注意拷贝构造函数的调用时机 // 撤消对象 t 6, 8 Destructor Called. // 撤消对象 p 1 #include <iostream> 8, 12 2 #include Destructor "./Point.h" Called. // 撤消临时对象 8, 3 12 using Destructor namespace std; Called. // 撤消对象 p2 6, 4 8 Destructor Called. // 撤消对象 p1 5 // 注意 :move 是普通函数, 不是类的成员函数 6 Point move(point p, int xoffset, int yoffset) // A Point p=p1 参数传递 7 { 8 int x = p.getx( )+xoffset; 9 int y = p.gety( )+yoffset; 10 Point t(x, y); 11 return t; // B 返回时创建临时对象 _t 调用拷贝构造; 先后撤销 t p 和 _t 12 } 13 int main( ) 14 { 15 Point p1(6, 8), p2; 16 p2 = move(p1, 2, 4); // A, B 对象为函数参数, 用实参对象初始化形参对象 return 0; 19 } 此程序运行结果是? 不同编译器对返回的处理方式不同, 输出结果因而不同 Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

36 程序运行结果 VS2017 拷贝构造函数拷贝构造函数的调用时机 6, 8 Copy-initialization Constructor Called. // A 8, 12 Copy-initialization Constructor Called. // B 创建临时对象 8, 理解拷贝构造函数的用法 12 Destructor Called., 注意拷贝构造函数的调用时机 // 撤消对象 t 6, 8 Destructor Called. // 撤消对象 p 1 #include <iostream> 8, 12 2 #include Destructor "./Point.h" Called. // 撤消临时对象 8, 3 12 using Destructor namespace std; Called. // 撤消对象 p2 6, 4 8 Destructor Called. // 撤消对象 p1 5 // 注意 :move 是普通函数, 不是类的成员函数 6 Point move(point p, int xoffset, int yoffset) // A Point p=p1 参数传递程序运行结果 GCC { 6, 8 8 Copy-initialization int x = p.getx( )+xoffset; Constructor Called. // A 9 8, 12 Destructor int y = p.gety( Called. )+yoffset; // 撤消对象 t 10 Point t(x, y); 6, 8 Destructor 11 return t; // Called. B 返回时创建临时对象 // 撤消对象 _t 调用拷贝构造 p ; 先后撤销 t p 和 _t 8, } Destructor Called. // 撤消对象 p2 6, 13 8intDestructor main( ) Called. // 撤消对象 p1 14 { 15 Point p1(6, 8), p2; 16 p2 = move(p1, 2, 4); // A, B 对象为函数参数, 用实参对象初始化形参对象 return 0; 19 } 此程序运行结果是? 不同编译器对返回的处理方式不同, 输出结果因而不同 Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

37 程序运行结果 VS2017 拷贝构造函数拷贝构造函数的调用时机 6, 8 Copy-initialization Constructor Called. // A 8, 12 Copy-initialization Constructor Called. // B 创建临时对象 8, 理解拷贝构造函数的用法 12 Destructor Called., 注意拷贝构造函数的调用时机 // 撤消对象 t 6, 8 Destructor Called. // 撤消对象 p 1 #include <iostream> 8, 12 2 #include Destructor "./Point.h" Called. // 撤消临时对象 8, 3 12 using Destructor namespace std; Called. // 撤消对象 p2 6, 4 8 Destructor Called. // 撤消对象 p1 5 // 注意 :move 是普通函数, 不是类的成员函数 6 Point move(point p, int xoffset, int yoffset) // A Point p=p1 参数传递程序运行结果 GCC { 6, 8 8 Copy-initialization int x = p.getx( )+xoffset; Constructor Called. // A 9 8, 12 Destructor int y = p.gety( Called. )+yoffset; // 撤消对象 t 10 Point t(x, y); 6, 8 Destructor 11 return t; // Called. B 返回时创建临时对象 // 撤消对象 _t 调用拷贝构造 p ; 先后撤销 t p 和 _t 8, } Destructor Called. // 撤消对象 p2 6, 13 8intDestructor main( ) Called. // 撤消对象 p1 14 { 15 Point p1(6, 8), p2; 临时对象如果函数返回值是一个对象 16 p2 = move(p1, 2, 4); // A, B 对象为函数参数, 用实参对象初始化形参对象 17 在 return t 时编译器悄悄地调用拷贝构造函数为局部对象 t 创建临时对象 18 (t 的副本 return_t), 0; 从而将局部对象拷贝到外部存储器 ; 19 } 在撤销对象时, 编译器先撤销函数内部的局部对象 t 和 p 后撤销被拷贝到此程序运行结果是外部存储器中的临时对象? 不同编译器对返回的处理方式不同 _t, 输出结果因而不同 Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

38 提纲构造函数与类型转换 1 拷贝构造函数 2 构造函数与类型转换 3 构造函数与对象成员 4 对象成员的初始化 5 总结与思考 Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

39 构造函数与类型转换利用构造函数进行类型转换 C++ 不同内置类型的变量之间可以相互赋值 1 double a = ; 2 int b = (int)a; 1 string str="abc"; 2 char *p=str.data(); Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

40 构造函数与类型转换利用构造函数进行类型转换 C++ 不同内置类型的变量之间可以相互赋值 1 double a = ; 2 int b = (int)a; 1 string str="abc"; 2 char *p=str.data(); 问题 : 如果有自定义类型复数类的对象 Complex c;, 能否执行 c = 5.0;, 即 : 将 5.0 做为实部,0 做为虚部的一个复数赋值给复数 c Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

41 构造函数与类型转换利用构造函数进行类型转换 C++ 不同内置类型的变量之间可以相互赋值 1 double a = ; 2 int b = (int)a; 1 string str="abc"; 2 char *p=str.data(); 问题 : 如果有自定义类型复数类的对象 Complex c;, 能否执行 c = 5.0;, 即 : 将 5.0 做为实部,0 做为虚部的一个复数赋值给复数 c C++ 不同自定义类型的变量之间也可以相互赋值 C++ 当时的设计目标之一就是 : 自定义类型要和内置类型有具同等地位 Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

42 构造函数与类型转换利用构造函数进行类型转换 C++ 不同内置类型的变量之间可以相互赋值 1 double a = ; 2 int b = (int)a; 1 string str="abc"; 2 char *p=str.data(); 问题 : 如果有自定义类型复数类的对象 Complex c;, 能否执行 c = 5.0;, 即 : 将 5.0 做为实部,0 做为虚部的一个复数赋值给复数 c C++ 不同自定义类型的变量之间也可以相互赋值 C++ 当时的设计目标之一就是 : 自定义类型要和内置类型有具同等地位内置类型 vs 自定义类型地位相同 : 内置类型支持的性能自定义类型也应该支持 Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

构造函数与类型转换利用构造函数进行类型转换 C++ 不同内置类型的变量之间可以相互赋值 1 double a = 123.456; 2 int b = (int)a; 1 string str="abc"; 2 char *p=str.data(); 问题 : 如果有自定义类型复数类的对象 Complex c;, 能否执行 c = 5.0;, 即 : 将 5.

43 构造函数与类型转换利用构造函数进行类型转换 C++ 不同内置类型的变量之间可以相互赋值 1 double a = ; 2 int b = (int)a; 1 string str="abc"; 2 char *p=str.data(); 问题 : 如果有自定义类型复数类的对象 Complex c;, 能否执行 c = 5.0;, 即 : 将 5.0 做为实部,0 做为虚部的一个复数赋值给复数 c C++ 不同自定义类型的变量之间也可以相互赋值 C++ 当时的设计目标之一就是 : 自定义类型要和内置类型有具同等地位内置类型 vs 自定义类型地位相同 : 内置类型支持的性能自定义类型也应该支持答案可以!!! 利用拷贝构造函数形如 1 c = Complex(5.0); // 利用拷贝构造函数进行类型转换 Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

44 构造函数与类型转换利用构造函数进行类型转换类型转换, 完整程序代码如下 : 1 #include <iostream> 2 using namespace std; 3 4 class Complex 5 { 6 double Real, Image; 7 public: 8 Complex(double x=0, double y =0) 9 { 10 Real = x; 11 Image = y; 12 Show( ); 13 cout<<" 调用了构造函数 \n"; 14 } 15 ~Complex( ) 16 { 17 Show( ); 18 cout<<" 调用了析构函数 \n"; 19 } 20 void Show( ) 21 { 22 cout<< ( <<Real<<, << Image<< ) ; 23 } 24 }; 25 int main( ) 26 { 27 Complex c1(3, 5), c2; // A 28 c1 = 8.0; // B 等价于 c1 = Complex(8.0); 29 c2 = Complex(9.0, 9.0); // C 30 return 0; 31 } Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

45 构造函数与类型转换利用构造函数进行类型转换类型转换, 完整程序代码如下 : 1 #include <iostream> 13 cout<<" 调用了构造函数 \n"; 程序运行结果 2 using namespace std; 14 } (3, 3 5) 调用了构造函数 // 在 A 行创建 c1 对象时 15, 调用构造函数 ~Complex( ) 4 class Complex 16 { (0, 0) 调用了构造函数 // 在 A 行创建 c2 对象时, 调用构造函数 5 { 17 Show( ); (8, 6 0) 调用了构造函数 double Real, Image; // 创建撤消临时对象 18,B 行 cout<<" 调用了析构函数 \n"; (8, 7 public: 0) 调用了析构函数 // 创建撤消临时对象 19,B} 行 8 Complex(double x=0, double y 20 (9, 9) 调用了构造函数 // 创建撤消临时对象,C void 行 Show( ) =0) 21 { (9, 9) 调用了析构函数 // 创建撤消临时对象,C 行 9 { 22 cout<< ( <<Real<<, << 10 (9, 9) 调用了析构函数 Real = x; // 在程序结束, 撤消 c2 对象时 Image<< ) ;, 调用析构函数 11 (8, 0) 调用了析构函数 Image = y; // 在程序结束, 撤消 23 c1 对象时 }, 调用析构函数 12 Show( ); 24 }; 25 int main( ) 26 { 27 Complex c1(3, 5), c2; // A 28 c1 = 8.0; // B 等价于 c1 = Complex(8.0); 29 c2 = Complex(9.0, 9.0); // C 30 return 0; 31 } Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

46 提纲构造函数与对象成员 1 拷贝构造函数 2 构造函数与类型转换 3 构造函数与对象成员 4 对象成员的初始化 5 总结与思考 Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

47 对象成员构造函数与对象成员对象成员 : 当一个类的成员是另一个类的对象时, 这个对象就叫对象成员, 也可称之为成员对象概括的说, 就是一个类的成员是另一个类的对象在创建新的类时, 经常将简单类的对象作为复杂类的对象成员这个新类和对象成员之间的关系是 has-a ( 从属 ) 关系, 即 The new class has-a (or an) object 让我们举例说明这个问题设计一个复杂类, 包含三个简单类的对象例一简单类 :Wheel Motor Chair 复杂类 :Car 例二简单类 : 点线段复杂类 : 矩形请描述这些类之间的逻辑关系, 并尝试编写伪代码 Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

48 对象成员构造函数与对象成员对象成员 : 当一个类的成员是另一个类的对象时, 这个对象就叫对象成员, 也可称之为成员对象概括的说, 就是一个类的成员是另一个类的对象在创建新的类时, 经常将简单类的对象作为复杂类的对象成员这个新类和对象成员之间的关系是 has-a ( 从属 ) 关系, 即 The new class has-a (or an) object 让我们举例说明这个问题设计一个复杂类, 包含三个简单类的对象例一简单类 :Wheel Motor Chair 复杂类 :Car 例二简单类 : 点线段复杂类 : 矩形请描述这些类之间的逻辑关系, 并尝试编写伪代码 Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

49 对象成员构造函数与对象成员对象成员 : 当一个类的成员是另一个类的对象时, 这个对象就叫对象成员, 也可称之为成员对象概括的说, 就是一个类的成员是另一个类的对象在创建新的类时, 经常将简单类的对象作为复杂类的对象成员这个新类和对象成员之间的关系是 has-a ( 从属 ) 关系, 即 The new class has-a (or an) object 让我们举例说明这个问题设计一个复杂类, 包含三个简单类的对象例一简单类 :Wheel Motor Chair 复杂类 :Car 例二简单类 : 点线段复杂类 : 矩形请描述这些类之间的逻辑关系, 并尝试编写伪代码 Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

50 对象成员构造函数与对象成员对象成员 : 当一个类的成员是另一个类的对象时, 这个对象就叫对象成员, 也可称之为成员对象概括的说, 就是一个类的成员是另一个类的对象在创建新的类时, 经常将简单类的对象作为复杂类的对象成员这个新类和对象成员之间的关系是 has-a ( 从属 ) 关系, 即 The new class has-a (or an) object 让我们举例说明这个问题设计一个复杂类, 包含三个简单类的对象例一简单类 :Wheel Motor Chair 复杂类 :Car 例二简单类 : 点线段复杂类 : 矩形请描述这些类之间的逻辑关系, 并尝试编写伪代码 Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

51 对象成员构造函数与对象成员对象成员 : 当一个类的成员是另一个类的对象时, 这个对象就叫对象成员, 也可称之为成员对象概括的说, 就是一个类的成员是另一个类的对象在创建新的类时, 经常将简单类的对象作为复杂类的对象成员这个新类和对象成员之间的关系是 has-a ( 从属 ) 关系, 即 The new class has-a (or an) object 让我们举例说明这个问题设计一个复杂类, 包含三个简单类的对象例一简单类 :Wheel Motor Chair 复杂类 :Car 例二简单类 : 点线段复杂类 : 矩形请描述这些类之间的逻辑关系, 并尝试编写伪代码 Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

52 构造函数与对象成员程序 Rectangle.h 代码 1 #include <iostream> 2 class Point 3 { 4 public: 5 // no constructor, use default 6 void setx(int newx) { x = newx; } 7 void sety(int newy) { y = newy; } 8 int getx() const { return x;} 9 int gety() const { return y;} 10 private: 11 int x; int y; 12 }; 13 class Rectangle 14 { 15 public: 16 Rectangle(int newtop, int newleft, int newbottom, int newright); 17 ~Rectangle() {} int gettop() const { return top; } 20 int getleft() const { return left; } 21 int getbottom() const { return bottom; } 22 int getright() const { return right; } Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

53 构造函数与对象成员程序 Rectangle.h 代码 23 Point getupperleft() const { return upperleft; } 24 Point getlowerleft() const { return lowerleft; } 25 Point getupperright() const { return upperright; } 26 Point getlowerright() const { return lowerright; } void setupperleft(point location); 29 void setlowerleft(point location); 30 void setupperright(point location); 31 void setlowerright(point location); void settop(int newtop); void setleft (int newleft); 34 void setbottom (int newbottom); void setright (int newright); int getarea() const; 37 private: 38 Point upperleft; Point upperright; 39 Point lowerleft; Point lowerright; 40 int top; int left; 41 int bottom; int right; 42 }; 请在 CodeBlocks 中测试 Rectangle.h Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

54 构造函数与对象成员程序 Rectangle.cpp 代码 1 #include "Rectangle.h" 2 3 Rectangle::Rectangle(int newtop, int newleft, int newbottom, int newright ) 4 { 5 top = newtop; 6 left = newleft; 7 bottom = newbottom; 8 right = newright; 9 10 upperleft.setx(left); 11 upperleft.sety(top); upperright.setx(right); 14 upperright.sety(top); lowerleft.setx(left); 17 lowerleft.sety(bottom); lowerright.setx(right); 20 lowerright.sety(bottom); 21 } Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

55 构造函数与对象成员程序 Rectangle.cpp 代码 void Rectangle::setUpperLeft(Point location) 24 { 25 upperleft = location; 26 upperright.sety(location.gety()); 27 lowerleft.setx(location.getx()); 28 top = location.gety(); 29 left = location.getx(); 30 } void Rectangle::setLowerLeft(Point location) 33 { 34 lowerleft = location; 35 lowerright.sety(location.gety()); 36 upperleft.setx(location.getx()); 37 bottom = location.gety(); 38 left = location.getx(); 39 } void Rectangle::setLowerRight(Point location) 42 { 43 lowerright = location; Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

56 构造函数与对象成员程序 Rectangle.cpp 代码 44 lowerleft.sety(location.gety()); 45 upperright.setx(location.getx()); 46 bottom = location.gety(); 47 right = location.getx(); 48 } void Rectangle::setUpperRight(Point location) 51 { 52 upperright = location; 53 upperleft.sety(location.gety()); 54 lowerright.setx(location.getx()); 55 top = location.gety(); 56 right = location.getx(); 57 } void Rectangle::setTop(int newtop) 60 { 61 top = newtop; 62 upperleft.sety(top); 63 upperright.sety(top); 64 } 65 Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

57 构造函数与对象成员程序 Rectangle.cpp 代码 66 void Rectangle::setLeft(int newleft) 67 { 68 left = newleft; 69 upperleft.setx(left); 70 lowerleft.setx(left); 71 } void Rectangle::setBottom(int newbottom) 74 { 75 bottom = newbottom; 76 lowerleft.sety(bottom); 77 lowerright.sety(bottom); 78 } void Rectangle::setRight(int newright) 81 { 82 right = newright; 83 upperright.setx(right); 84 lowerright.setx(right); 85 } int Rectangle::getArea() const Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

58 构造函数与对象成员程序 Rectangle.cpp 代码 88 { 89 int width = right - left; 90 int height = top - bottom; 91 return (width * height); 92 } // compute area of the rectangle by finding corners, 95 // establish width and height and then multiply 96 int main() 97 { 98 // initialize a local Rectangle variable 99 Rectangle myrectangle(100, 20, 50, 80 ); int area = myrectangle.getarea(); std::cout << "Area: " << area << "\n"; 104 std::cout << "Upper Left X Coordinate: "; 105 std::cout << myrectangle.getupperleft().getx() << "\n"; 106 return 0; 107 } 请在 CodeBlocks 中测试 Rectangle.cpp Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

59 提纲对象成员的初始化 1 拷贝构造函数 2 构造函数与类型转换 3 构造函数与对象成员 4 对象成员的初始化 5 总结与思考 Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

60 对象成员的初始化对象成员的声明格式在产生新定义类的对象时必须对新定义类的对象成员进行初始化, 且只能通过新类的构造函数完成对其所有成员的初始化初始化新类的对象时, 先调用对象成员的构造函数完成对象成员的初始化, 再调用对象自身的构造函数完成其他成员的初始化对象销毁时, 析构函数的调用顺序与构造函数的调用顺序相反在类的定义中, 声明对象成员的一般格式为 : 1 class ClassName 2 { 3 ClassName1 c1; // ClassName1-n 是已定义的类名 ClassNamen cn; 6 int x1,..., xn; // x1-xn 是内置类型的变量名 7 public: 8 ClassName(ArgsList) : c1 (arg1),..., cn (argn) 9 {...} }MyObject(ArgsList); Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

61 对象成员的初始化对象成员的声明格式在产生新定义类的对象时必须对新定义类的对象成员进行初始化, 且只能通过新类的构造函数完成对其所有成员的初始化初始化新类的对象时, 先调用对象成员的构造函数完成对象成员的初始化, 再调用对象自身的构造函数完成其他成员的初始化对象销毁时, 析构函数的调用顺序与构造函数的调用顺序相反在类的定义中, 声明对象成员的一般格式为 : 1 class ClassName 2 { 3 ClassName1 c1; // ClassName1-n 是已定义的类名 ClassNamen cn; 6 int x1,..., xn; // x1-xn 是内置类型的变量名 7 public: 8 ClassName(ArgsList) : c1 (arg1),..., cn (argn) 9 {...} }MyObject(ArgsList); Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

62 对象成员的初始化对象成员的声明格式在产生新定义类的对象时必须对新定义类的对象成员进行初始化, 且只能通过新类的构造函数完成对其所有成员的初始化初始化新类的对象时, 先调用对象成员的构造函数完成对象成员的初始化, 再调用对象自身的构造函数完成其他成员的初始化对象销毁时, 析构函数的调用顺序与构造函数的调用顺序相反在类的定义中, 声明对象成员的一般格式为 : 1 class ClassName 2 { 3 ClassName1 c1; // ClassName1-n 是已定义的类名 ClassNamen cn; 6 int x1,..., xn; // x1-xn 是内置类型的变量名 7 public: 8 ClassName(ArgsList) : c1 (arg1),..., cn (argn) 9 {...} }MyObject(ArgsList); Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

63 对象成员的初始化对象成员的声明格式在产生新定义类的对象时必须对新定义类的对象成员进行初始化, 且只能通过新类的构造函数完成对其所有成员的初始化初始化新类的对象时, 先调用对象成员的构造函数完成对象成员的初始化, 再调用对象自身的构造函数完成其他成员的初始化对象销毁时, 析构函数的调用顺序与构造函数的调用顺序相反在类的定义中, 声明对象成员的一般格式为 : 1 class ClassName 2 { 3 ClassName1 c1; // ClassName1-n 是已定义的类名 ClassNamen cn; 6 int x1,..., xn; // x1-xn 是内置类型的变量名 7 public: 8 ClassName(ArgsList) : c1 (arg1),..., cn (argn) 9 {...} }MyObject(ArgsList); Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

64 对象成员的初始化对象成员的声明格式在产生新定义类的对象时必须对新定义类的对象成员进行初始化, 且只能通过新类的构造函数完成对其所有成员的初始化初始化新类的对象时, 先调用对象成员的构造函数完成对象成员的初始化, 再调用对象自身的构造函数完成其他成员的初始化对象销毁时, 析构函数的调用顺序与构造函数的调用顺序相反在类的定义中, 声明对象成员的一般格式为 : 1 class ClassName 2 { 3 ClassName1 c1; // ClassName1-n 是已定义的类名 ClassNamen cn; 6 int x1,..., xn; // x1-xn 是内置类型的变量名 7 public: 8 ClassName(ArgsList) : c1 (arg1),..., cn (argn) 9 {...} }MyObject(ArgsList); Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

65 对象成员的初始化对象成员的初始化列表 ArgsList 中的形参必须带有类型说明, 而 arg1,...,argn 是实参, 不需要类型说明, 它们可以是来自于 ArgsList 的变量, 也可以是常量表达式或其他形式请思考 : 为什么 arg1,...,argn 不需要类型说明? 对象成员构造函数的调用顺序由对象成员的定义顺序决定 ( 先定义者先被调用 ), 而与成员在初始化列表中的顺序无关请思考 : 为什么与写在成员初始化列表中的顺序无关, 而与对象成员的定义顺序有关? 原因是 : Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

66 对象成员的初始化对象成员的初始化列表 ArgsList 中的形参必须带有类型说明, 而 arg1,...,argn 是实参, 不需要类型说明, 它们可以是来自于 ArgsList 的变量, 也可以是常量表达式或其他形式请思考 : 为什么 arg1,...,argn 不需要类型说明? 对象成员构造函数的调用顺序由对象成员的定义顺序决定 ( 先定义者先被调用 ), 而与成员在初始化列表中的顺序无关请思考 : 为什么与写在成员初始化列表中的顺序无关, 而与对象成员的定义顺序有关? 原因是 : Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

67 对象成员的初始化对象成员的初始化列表 ArgsList 中的形参必须带有类型说明, 而 arg1,...,argn 是实参, 不需要类型说明, 它们可以是来自于 ArgsList 的变量, 也可以是常量表达式或其他形式请思考 : 为什么 arg1,...,argn 不需要类型说明? 原因是 : 1 参数 arg1,...,argn 为已声明过的实参, 所以不需要类型说明对象成员构造函数的调用顺序由对象成员的定义顺序决定 ( 先定义者先被调用 ), 而与成员在初始化列表中的顺序无关请思考 : 为什么与写在成员初始化列表中的顺序无关, 而与对象成员的定义顺序有关? 原因是 : Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

68 对象成员的初始化对象成员的初始化列表 ArgsList 中的形参必须带有类型说明, 而 arg1,...,argn 是实参, 不需要类型说明, 它们可以是来自于 ArgsList 的变量, 也可以是常量表达式或其他形式请思考 : 为什么 arg1,...,argn 不需要类型说明? 原因是 : 1 参数 arg1,...,argn 为已声明过的实参, 所以不需要类型说明对象成员构造函数的调用顺序由对象成员的定义顺序决定 ( 先定义者先被调用 ), 而与成员在初始化列表中的顺序无关请思考 : 为什么与写在成员初始化列表中的顺序无关, 而与对象成员的定义顺序有关? 原因是 : Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

69 对象成员的初始化对象成员的初始化列表 ArgsList 中的形参必须带有类型说明, 而 arg1,...,argn 是实参, 不需要类型说明, 它们可以是来自于 ArgsList 的变量, 也可以是常量表达式或其他形式请思考 : 为什么 arg1,...,argn 不需要类型说明? 原因是 : 1 参数 arg1,...,argn 为已声明过的实参, 所以不需要类型说明对象成员构造函数的调用顺序由对象成员的定义顺序决定 ( 先定义者先被调用 ), 而与成员在初始化列表中的顺序无关请思考 : 为什么与写在成员初始化列表中的顺序无关, 而与对象成员的定义顺序有关? 原因是 : Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

70 对象成员的初始化对象成员的初始化列表 ArgsList 中的形参必须带有类型说明, 而 arg1,...,argn 是实参, 不需要类型说明, 它们可以是来自于 ArgsList 的变量, 也可以是常量表达式或其他形式请思考 : 为什么 arg1,...,argn 不需要类型说明? 原因是 : 1 参数 arg1,...,argn 为已声明过的实参, 所以不需要类型说明对象成员构造函数的调用顺序由对象成员的定义顺序决定 ( 先定义者先被调用 ), 而与成员在初始化列表中的顺序无关请思考 : 为什么与写在成员初始化列表中的顺序无关, 而与对象成员的定义顺序有关? 原因是 : 1 类的声明是唯一的, 而类构造函数可以有很多, 对象成员在不同初始化列表中的次序并不一定完全相同 Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

71 对象成员的初始化对象成员的初始化列表 ArgsList 中的形参必须带有类型说明, 而 arg1,...,argn 是实参, 不需要类型说明, 它们可以是来自于 ArgsList 的变量, 也可以是常量表达式或其他形式请思考 : 为什么 arg1,...,argn 不需要类型说明? 原因是 : 1 参数 arg1,...,argn 为已声明过的实参, 所以不需要类型说明对象成员构造函数的调用顺序由对象成员的定义顺序决定 ( 先定义者先被调用 ), 而与成员在初始化列表中的顺序无关请思考 : 为什么与写在成员初始化列表中的顺序无关, 而与对象成员的定义顺序有关? 原因是 : 1 类的声明是唯一的, 而类构造函数可以有很多, 对象成员在不同初始化列表中的次序并不一定完全相同 2 如果对象成员按照它们在初始化表中的次序进行构造, 这将导致析构函数无法得到唯一的逆序, 也难以得到合理的逆序 Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

72 对象成员的初始化对象成员的初始化列表 ArgsList 中的形参必须带有类型说明, 而 arg1,...,argn 是实参, 不需要类型说明, 它们可以是来自于 ArgsList 的变量, 也可以是常量表达式或其他形式请思考 : 为什么 arg1,...,argn 不需要类型说明? 原因是 : 1 参数 arg1,...,argn 为已声明过的实参, 所以不需要类型说明对象成员构造函数的调用顺序由对象成员的定义顺序决定 ( 先定义者先被调用 ), 而与成员在初始化列表中的顺序无关请思考 : 为什么与写在成员初始化列表中的顺序无关, 而与对象成员的定义顺序有关? 原因是 : 1 类的声明是唯一的, 而类构造函数可以有很多, 对象成员在不同初始化列表中的次序并不一定完全相同 2 如果对象成员按照它们在初始化表中的次序进行构造, 这将导致析构函数无法得到唯一的逆序, 也难以得到合理的逆序 3 如果对象成员按照初始化表进行构造, 则必须追踪初始化列表中成员的顺序才能得到合理的逆序现在则节省了追踪初始化列表中成员顺序的成本 Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

73 对象成员的初始化对象成员的初始化列表如将程序 PointObjectInLine 中的 A 行 1 Line(int x1, int y1, int x2, int y2, int w, int c) : p1(x1,y1), p2(x2,y2) 改写为 1 Line(int x1, int y1, int x2, int y2, int w, int c) : p2(x2,y2), p1(x1,y1) 仍然是先调用 p1(x1, y1) 后调用 p2(x2, y2) 这是因为: Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

74 对象成员的初始化对象成员的初始化列表如将程序 PointObjectInLine 中的 A 行 1 Line(int x1, int y1, int x2, int y2, int w, int c) : p1(x1,y1), p2(x2,y2) 改写为 1 Line(int x1, int y1, int x2, int y2, int w, int c) : p2(x2,y2), p1(x1,y1) 仍然是先调用 p1(x1, y1) 后调用 p2(x2, y2) 这是因为 : 1 对象成员构造函数的顺序由对象成员的定义顺序决定, 先定义者先被调用 2 由于 p1 的定义在前,p2 的定义在后, 所以先调用 p1(x1, y1) 后调用 p2(x2, y2) Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

75 对象成员的初始化对象成员的初始化列表如将程序 PointObjectInLine 中的 A 行 1 Line(int x1, int y1, int x2, int y2, int w, int c) : p1(x1,y1), p2(x2,y2) 改写为 1 Line(int x1, int y1, int x2, int y2, int w, int c) : p2(x2,y2), p1(x1,y1) 仍然是先调用 p1(x1, y1) 后调用 p2(x2, y2) 这是因为 : 1 对象成员构造函数的顺序由对象成员的定义顺序决定, 先定义者先被调用 2 由于 p1 的定义在前,p2 的定义在后, 所以先调用 p1(x1, y1) 后调用 p2(x2, y2) 以下三种情况下需要使用初始化成员列表需要初始化的数据成员是另一个类的对象, 即对象成员需要初始化 const 修饰的数据成员或引用类型的数据成员需要由派生 ( 子 ) 类初始化基 ( 父 ) 类的私有数据成员 Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

76 对象成员的初始化使用初始化列表的情形第一种情况 : 数据成员是对象, 并且这个对象只有带参数的构造函数, 没有默认构造函数第二种情况 : 类的成员是引用类型或者是被 const 修饰的数据成员第三种情况 : 派生 ( 子 ) 类初始化基 ( 父 ) 类的私有成员 Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

77 对象成员的初始化使用初始化列表的情形第一种情况 : 数据成员是对象, 并且这个对象只有带参数的构造函数, 没有默认构造函数如果类的某个成员是另一个类 ( 或结构体 ) 的对象, 而且这个成员它只有一个带参数的构造函数, 而没有默认构造函数, 那么对这个成员进行初始化时, 就必须调用这个成员带参数的构造函数如果没有初始化列表, 将无法完成对象初始化的第一步 ( 数据成员的初始化 ), 就会报错第二种情况 : 类的成员是引用类型或者是被 const 修饰的数据成员当类成员中含有一个 const 对象时, 或者是一个引用时, 也必须通过成员初始化列表进行初始化这是因为, 这两种对象要在声明后马上初始化, 否则就要在构造函数中对它们赋值 ( 然而, 这是不允许的 ) 第三种情况 : 派生 ( 子 ) 类初始化基 ( 父 ) 类的私有成员当派生类初始化基类的私有成员时, 需要在 ( 并且也只能在 ) 参数初始化列表中显式地调用基类的构造函数在继承与派生章节对此详细介绍 Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

78 对象成员的初始化使用初始化列表的情形第一种情况 : 数据成员是对象, 并且这个对象只有带参数的构造函数, 没有默认构造函数如果类的某个成员是另一个类 ( 或结构体 ) 的对象, 而且这个成员它只有一个带参数的构造函数, 而没有默认构造函数, 那么对这个成员进行初始化时, 就必须调用这个成员带参数的构造函数如果没有初始化列表, 将无法完成对象初始化的第一步 ( 数据成员的初始化 ), 就会报错 InitializeListCondition1.cpp 第二种情况 : 类的成员是引用类型或者是被 const 修饰的数据成员当类成员中含有一个 const 对象时, 或者是一个引用时, 也必须通过成员初始化列表进行初始化这是因为, 这两种对象要在声明后马上初始化, 否则就要在构造函数中对它们赋值 ( 然而, 这是不允许的 ) InitializeListCondition2.cpp 第三种情况 : 派生 ( 子 ) 类初始化基 ( 父 ) 类的私有成员当派生类初始化基类的私有成员时, 需要在 ( 并且也只能在 ) 参数初始化列表中显式地调用基类的构造函数在继承与派生章节对此详细介绍 InitializeListCondition3.cpp Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

79 对象成员的初始化关于初始化列表的说明第一种情况 : 数据成员是对象, 并且这个对象只有带参数的构造函数, 没有默认构造函数 1 #include <iostream> 2 using namespace std; 3 // 定义一个类 4 class Test 5 { 6 public: 7 Test (int, int, int) 8 { 9 cout <<"Test"<<endl; 10 }; 11 private: 12 int x; 13 int y; 14 int z; 15 }; 程序输出结果 : 16 class Mytest 17 { 18 public: 19 Mytest():test(1,2,3)// 初始化 20 { 21 cout <<"Mytest"<<endl; 22 }; 23 private: 24 Test test; // 声明 25 }; 26 int main(int argc, char* argv[]) 27 { 28 Mytest test; 29 return 0; 30 } Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

80 对象成员的初始化关于初始化列表的说明第一种情况 : 数据成员是对象, 并且这个对象只有带参数的构造函数, 没有默认构造函数 1 #include <iostream> 2 using namespace std; 3 // 定义一个类 4 class Test 5 { 6 public: 7 Test (int, int, int) 8 { 9 cout <<"Test"<<endl; 10 }; 11 private: 12 int x; 13 int y; 14 int z; 15 }; 程序输出结果 : Test Mytest 16 class Mytest 17 { 18 public: 19 Mytest():test(1,2,3)// 初始化 20 { 21 cout <<"Mytest"<<endl; 22 }; 23 private: 24 Test test; // 声明 25 }; 26 int main(int argc, char* argv[]) 27 { 28 Mytest test; 29 return 0; 30 } 构造函数调用顺序 : Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

81 对象成员的初始化关于初始化列表的说明第一种情况 : 数据成员是对象, 并且这个对象只有带参数的构造函数, 没有默认构造函数 1 #include <iostream> 2 using namespace std; 3 // 定义一个类 4 class Test 5 { 6 public: 7 Test (int, int, int) 8 { 9 cout <<"Test"<<endl; 10 }; 11 private: 12 int x; 13 int y; 14 int z; 15 }; 程序输出结果 : Test Mytest 16 class Mytest 17 { 18 public: 19 Mytest():test(1,2,3)// 初始化 20 { 21 cout <<"Mytest"<<endl; 22 }; 23 private: 24 Test test; // 声明 25 }; 26 int main(int argc, char* argv[]) 27 { 28 Mytest test; 29 return 0; 30 } 构造函数调用顺序 : Test() Mytest() Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

82 对象成员的初始化关于初始化列表的说明第二种情况 : 类的成员是引用类型或者是被 const 修饰的数据成员 1 class Test 2 { 3 priate: 4 const int a; //const 成员的声明 5 public: 6 Test():a(10) {} // 初始化 7 }; 或 1 class Test 2 { 3 private: 4 int &a; // 引用的声明 5 public: 6 Test(int x):a(x) {} // 初始化 7 } 当类成员中含有一个 const 对象或一个引用时, 也必须通过初始化列表进行初始化, 不允许在构造函数中对它们赋值 Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

83 对象成员的初始化关于初始化列表的说明第三种情况 : 派生 ( 子 ) 类初始化基 ( 父 ) 类的私有成员 ( 暂不详述 ) 1 #include "iostream" 2 using namespace std; 3 class Test 4 { 5 public: 6 Test() { } 7 Test(int x) 8 { 9 int_x = x; 10 } 11 void show() 12 { 13 cout<< int_x << endl; 14 } 15 private: 16 int int_x; 17 }; 1 class Mytest : public Test 2 { 3 public: 4 Mytest() : Test(110) 5 { 6 //Test(110); // 构造函数只能在初始化列表中被显式调用, 不能在构造函数内部被显示调用, 如果无注释符则错 7 }; 8 }; 9 int main(int argc, char* argv[]) 10 { 11 Test *p = new Mytest(); 12 p->show(); 13 return 0; 14 } 当派生类初始化基类的私有成员时, 需要在并且也只能在参数初始化列表中显式调用基类的构造函数 Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

84 对象成员的初始化对象数组与对象成员扩充 : 对象数组, 栈中实例化和堆中实例化 1 class Coordinate 2 { 3 public: 4 int m_x; 5 int m_y; 6 }; 7 int main() 8 { 9 Coordinate coord[3]; // 栈中实例化 10 coord[1].m_x = 10; 11 Coordinate * p = new Coordinate[3]; // 堆中实例化 12 p[0].m_y = 20; // p->m_y = delete [] p; 14 p = NULL; 15 return 0; 16 } Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

85 对象成员的初始化对象数组与对象成员扩充 : 对象数组, 栈中实例化和堆中实例化 1 class Coordinate 2 { 3 public: 4 int m_x; 5 int m_y; 6 }; 7 int main() 8 { 9 Coordinate coord[3]; // 栈中实例化 10 coord[1].m_x = 10; 11 Coordinate * p = new Coordinate[3]; // 堆中实例化 12 p[0].m_y = 20; // p->m_y = delete [] p; 14 p = NULL; 15 return 0; 16 } 在使用 new 申请数组空间后, 就要用 delete [] p 来释放内存申请对象数组时调用了 n 次构造函数, 在释放时就要调用 n 次析构函数如果忘掉 [], 那么只销毁指向指针的第一个元素 Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

86 对象成员的初始化对象数组与对象成员扩充 : 对象成员 ( 对象包含对象 ) 的实例化 1 class Coordinate // 坐标系上的点 2 { 3 public: 4 Coordinate(){ } 5 private: 6 int m_x; int m_y; 7 }; 8 class Line // 坐标系上的线 9 { 10 public: 11 Line(){ } 12 private: 13 Coordinate m_a; Coordinate m_b; 14 }; 15 int main() 16 { 17 Line *p = new Line(); delete p; p = NULL; return 0; 18 } Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

87 对象成员的初始化对象数组与对象成员扩充 : 对象成员 ( 对象包含对象 ) 的实例化 1 class Coordinate // 坐标系上的点 2 { 3 public: 4 Coordinate(){ } 5 private: 6 int m_x; int m_y; 7 }; 8 class Line // 坐标系上的线 9 { 10 public: 11 Line(){ } 12 private: 13 Coordinate m_a; Coordinate m_b; 14 }; 15 int main() 16 { 17 Line *p = new Line(); delete p; p = NULL; return 0; 18 } 在实例化线的时, 先实例化 A 点, 其次实例化 B 点, 最后实例化线 ; 对象成员销毁的过程与对象成员创建的过程正好相反 Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

88 深拷贝和浅拷贝对象成员的初始化扩充 : 拷贝构造函数之浅拷贝, 正确的代码 1 class Array 2 { 3 public: 4 Array() 5 { m_icount=5; } 6 Array(const Array & arr) 7 { m_icount=arr.m_icount; } 8 private: 8 int m_icount; 9 }; 10 int main() 11 { 12 Array arr1; 13 Array arr2=arr1; 14 return 0; 15 } Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

89 浅拷贝和深拷贝对象成员的初始化扩充 : 拷贝构造函数之浅拷贝, 错误的代码 1 class Array{ 2 public: 3 Array(){ m_icount=5; m_parr=new int[m_icount]; } 4 Array(const Array & arr)// 浅拷贝 5 { m_icounta = arr.m_icount; 6 m_parr = arr.m_parr; } 7 private: 9 int m_icount; 10 int * m_parr; // 指针 11 }; 12 int main(){ 13 Array arr1; 14 Array arr2=arr1;// 浅拷贝 15 return 0; 16 } Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

$浅拷贝和深拷贝对象成员的初始化扩充 : 拷贝构造函数之浅拷贝, 错误的代码 ( 应采用深拷贝 ) 1 class Array{ 2 public: 3 Array(){ m_icount=5; m_parr=new int[m_icount]; } 4 Array(const Array & arr)// 浅拷贝 5 { m_icounta = arr.$

90 浅拷贝和深拷贝对象成员的初始化扩充 : 拷贝构造函数之浅拷贝, 错误的代码 ( 应采用深拷贝 ) 1 class Array{ 2 public: 3 Array(){ m_icount=5; m_parr=new int[m_icount]; } 4 Array(const Array & arr)// 浅拷贝 5 { m_icounta = arr.m_icount; 6 m_parr = arr.m_parr; } 7 private: 9 int m_icount; 10 int * m_parr; // 指针 11 }; 12 int main(){ 13 Array arr1; 14 Array arr2=arr1;// 浅拷贝 15 return 0; 16 } Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

$浅拷贝和深拷贝对象成员的初始化扩充 : 拷贝构造函数之深拷贝, 正确的代码 ( 涉及动态内存 ) 1 class Array 2 { 3 public: 4 Array(){ m_icount=5; m_parr=new int[m_icount]; } 5 Array(const Array & arr)// 深拷贝 6 { 7 m_icounta = arr.$

91 浅拷贝和深拷贝对象成员的初始化扩充 : 拷贝构造函数之深拷贝, 正确的代码 ( 涉及动态内存 ) 1 class Array 2 { 3 public: 4 Array(){ m_icount=5; m_parr=new int[m_icount]; } 5 Array(const Array & arr)// 深拷贝 6 { 7 m_icounta = arr.m_icount; 8 m_parr = new int[m_icount]; 9 for(int i=0; i < m_icount; i++) 10 { m_parr[i] = arr.m_parr[i]; } 9 } 10 private: 11 int m_icount; 12 int * m_parr; // 指针 13 }; 14 int main() 15 { 16 Array arr1; 17 Array arr2=arr1;// 深拷贝 18 return 0; 19 } Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

92 提纲总结与思考 1 拷贝构造函数 2 构造函数与类型转换 3 构造函数与对象成员 4 对象成员的初始化 5 总结与思考 Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

93 总结与思考总结与思考什么是拷贝构造函数? 它有什么作用? 调用拷贝构造函数发生在什么时机? 有哪几种情况? 编译器会生成默认的拷贝构造函数吗? Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

94 总结与思考总结与思考什么是拷贝构造函数? 它有什么作用? 拷贝构造函数是一种特殊的构造函数, 用来完成一些基于同一类的非当前对象的构建及初始化调用拷贝构造函数发生在什么时机? 有哪几种情况? 编译器会生成默认的拷贝构造函数吗? Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

95 总结与思考总结与思考什么是拷贝构造函数? 它有什么作用? 拷贝构造函数是一种特殊的构造函数, 用来完成一些基于同一类的非当前对象的构建及初始化调用拷贝构造函数发生在什么时机? 有哪几种情况? 三种情况 : 一个对象以值传递的方式传入函数体 ; 一个对象以值传递的方式从函数返回 ; 一个对象需要通过另一个对象进行初始化编译器会生成默认的拷贝构造函数吗? Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

总结与思考总结与思考什么是拷贝构造函数? 它有什么作用? 拷贝构造函数是一种特殊的构造函数, 用来完成一些基于同一类的非当前对象的构建及初始化调用拷贝构造函数发生在什么时机? 有哪几种情况? 三种情况 : 一个对象以值传递的方式传入函数体 ; 一个对象以值传递的方式从函数返回 ; 一个对象需要通过另一个对象进行初始化编译器会生成默认的拷贝构造函数吗?

96 总结与思考总结与思考什么是拷贝构造函数? 它有什么作用? 拷贝构造函数是一种特殊的构造函数, 用来完成一些基于同一类的非当前对象的构建及初始化调用拷贝构造函数发生在什么时机? 有哪几种情况? 三种情况 : 一个对象以值传递的方式传入函数体 ; 一个对象以值传递的方式从函数返回 ; 一个对象需要通过另一个对象进行初始化编译器会生成默认的拷贝构造函数吗? 1 如果用户没有自定义拷贝构造函数, 并且在代码中使用到了拷贝构造函数, 编译器就会生成默认的拷贝构造函数 2 如果用户定义了一个构造函数, 但不是拷贝构造函数, 而此时代码中又用到了拷贝构造函数, 那编译器也会生成默认的拷贝构造函数 3 如果用户定义了拷贝构造函数, 编译器就不会生成默认的拷贝构造函数 Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

97 总结与思考总结与思考问题一 : 写出下列程序输出结果 1 class CopyCons 2 { 3 public: 4 CopyCons(int i,int j,int k) 5 { 6 a = i; b = j; c = k; 7 cout << " 有参构造 " << i << \n ; 8 } 9 ~CopyCons() 10 { cout << " 对象析构 \n"; } 11 int getc() 12 { return a; } 13 private: 14 int a,b,c; 15 }; 16 class Test 17 { 18 public: 19 Test():p(1,2,3),q(4,5,6),x(7) 20 { cout << " 构造 Test\n"; } 21 ~Test() 22 { cout << " 析构 Test\n"; } 23 Test(const Test &obj):p (8,9,10),q(11,12,13),x(14) 24 { cout << " 拷贝构造 \n"; } 25 CopyCons p, q; // 注意 26 int x; 27 }; 28 void show(test mytest) 29 { 30 cout << " 我的测试 " << mytest.p.getc()<<endl; 31 } 32 int main() 33 { 34 Test mytest; 35 show(mytest); 36 return 0; 37 } Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

98 总结与思考总结与思考程序输出结果是 Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

99 总结与思考总结与思考问题二 : 写出下列程序输出结果 1 class CopyCons 2 { 3 public: 4 CopyCons(int i,int j,int k) 5 { 6 a = i; b = j; c = k; 7 cout << " 有参构造 " << i << \n ; 8 } 9 ~CopyCons() 10 { cout << " 对象析构 \n"; } 11 int getc() 12 { return a; } 13 private: 14 int a,b,c; 15 }; 16 class Test 17 { 18 public: 19 Test():p(1,2,3),q(4,5,6),x(7) 20 { cout << " 构造 Test\n"; } 21 ~Test() 22 { cout << " 析构 Test\n"; } 23 Test(const Test &obj):p (8,9,10),q(11,12,13),x(14) 24 { cout << " 拷贝构造 \n"; } 25 CopyCons q, p; // 注意 26 int x; 27 }; 28 void show(test mytest) 29 { 30 cout << " 我的测试 " << mytest.p.getc()<<endl; 31 } 32 int main() 33 { 34 Test mytest; 35 show(mytest); 36 return 0; 37 } Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

100 总结与思考总结与思考程序输出结果是 Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

101 总结与思考作业总结与思考选择题 1 下列说法中错误的是 a a a a a A) 如果用户不定义缺省构造函数, 则系统自动生成一个缺省构造函数 B) 如果用户不定义拷贝构造函数, 则系统自动生成一个拷贝构造函数 C) 如果用户不定义析构函数, 则系统自动生成一个默认的析构函数 D) 如果用户定义了析构函数, 则系统就不会自动生成任何析构函数 2 下列说法中正确的是 a a a a a A) 类与对象的关系就是数据类型与变量的关系 B) 对象是类的一个实例 C) 任何一个对象必定属于一个特定的类 D) 一个类只能有一个对象 E) 类的普通成员函数可以设置参数的缺省值 F) 类的静态成员函数不能声明为类的内联函数 G) 声明为内联的成员函数一定可以减少调用开销简答题 3 什么是拷贝构造函数? 拷贝构造函数用于哪三个方面? Dongke Sun (Southeast University) C++ Programming and Algorithms Spring semester, / 51

展开

エスポラージュ株式会社住所 : 東京都江東区大島東急ドエルアルス大島 HP: ******************* * 关于 Java 测试试题 ******

エスポラージュ株式会社住所 : 東京都江東区大島東急ドエルアルス大島 HP: ******************* * 关于 Java 测试试题 ****** ******************* * 关于 Java 测试试题 ******************* 問 1 运行下面的程序, 选出一个正确的运行结果 public class Sample { public static void main(string[] args) { int[] test = { 1, 2, 3, 4, 5 ; for(int i = 1 ; i System.out.print(test[i]);

程序设计与算法语言 拷贝构造 C/C++ Programming and Algorithms Copy Constructor Dongke Sun ( 孙东科 ) 东南大学机械工程学院 School of Mechanical Engineering South

程序设计与算法语言拷贝构造 C/C++ Programming and Algorithms Copy Constructor Dongke Sun ( 孙东科 ) 东南大学机械工程学院 School of Mechanical Engineering South