0816，特殊数据成员/成员函数，对象构造，delete/new，单例模式

01 特殊的数据成员 (是我写作业不看标题

1，常量数据成员
加上const 的数据成员，加上之后只能在声明和初始化队列中举行初始化，初始化之后不能举行赋值利用
2，引用数据数据成员
用引用方式创建的数据成员
引用数据成员须要在初始化列表中举行初始化
须要绑定一个已经存在的，在引用成员的生命周期内始终有效的变量（对象
3，对象成员
一个类的对象是其他类的数据成员
coution：
初始化列表写对象，不写类名，不能在声明对象成员时直接用有参构造创建
假如在初始化列表中没有表现的初始化对象成员，编译器回主动调用对象成员的默认无参构造大概全部参数都有默认值的有参
堆空间资源采取序次（类的对象-->对象成员）
4，静态数据成员
加上static修饰的数据成员
存储在全局/静态区，不占据对象的存储空间，静态数据成员被整个类的全部对象共享
规则：
4.1 private 的静态数据成员无法在类之外直接访问
4.2 初始化必须放在类外（一样平常紧接类界说
4.3 初始化时不能在前面+static，要加类名+作用域限定符
4.4 多条初始化序次和声明序次划一
4.5 对象访问 & 类名：：访问
001const.cc

2. #include <iostream>
3. using std::cout;
4. using std::endl;
6. class Point{
7. public:
8.     Point()
9.         //只能用 这种 严格意义的初始化
10.         /* :_ix(0),_iy(0) */
11.         {cout<<"Point()"<<endl;}
12.     Point(int x,int y=1)
13.         :_ix(x),_iy(y) //const int _ix=x;
14.                        //can't _ix=x;
15.         {cout<<"Point(int ,int)"<<endl;}
16.     Point(const Point & p)
17.         :_ix(p._ix),_iy(p._iy)
18.         {cout<<"Point(Point &)"<<endl;}
19.     void print(){ cout<<_ix<<"\t\t"<<_iy<<endl; }
20. private:
21.    const  int _ix=1;
22.    const  int _iy=1;
23.    //备胎中的备胎
24.    //只能算声明
25.    /* const  int _ix; */
26.    /* const  int _iy; */
27. };
29. void test(){
30.     Point pt1;
31.     Point pt2(5);
32.     Point pt(1,2);
33.     Point pt3(pt1);
35.     /* pt3=pt2; */
36.     //声明了常量数据成员，不能进行常规意义的赋值操作
37.     pt1.print();
38. }
40. int main(void)
41. {
42.     test();
43.     return 0;
44. }

复制代码

002refmember.cc

2. #include <iostream>
3. using std::cout;
4. using std::endl;
6. int gNum=100;
7. //只能绑定一个已经存在，在引用期间成员的生命周期内
8. //始终有效的变量（对象
9. class Point{
10. public:
11.     Point()
12.         :_ix(0),_iy(0)
13.          ,_ref(_ix)
14.         {cout<<"Point()"<<endl;}
15.     Point(int x,int y=1)
16.         :_ix(x),_iy(y) //const int _ix=x;
17.         /* ,_ref(_ix) */
18.         {cout<<"Point(int ,int)"<<endl;}
19.     /* Point(int x,int y,int z) */
20.     /*     :_ix(x),_iy(y) //const int _ix=x; */
21.     /*     ,_ref(z) */
22.     /*     {cout<<"Point(int ,int,int)"<<endl;} */
23.     Point(const Point & p)
24.         :_ix(p._ix),_iy(p._iy)
25.          ,_ref(p._ref)
26.         {cout<<"Point(Point &)"<<endl;}
27.     void print(){ cout<<_ix<<"\t\t"<<_iy<<"\t\t"<<_ref<<endl; }
28. private:
29.     int _ix;
30.     int _iy;
31.     /* int & _ref; */
32.     int & _ref=gNum;
33.     /* int & _ref=_iy; */
34. };
36. void test(){
37.     Point pt1;
38.     /* Point pt2(5,6,7); //7生命周期？一个牛逼的数字 */
39.     Point pt2(pt1);
40.     Point pt3(1,2);
41.     Point pt4(9);
43.     /* pt3=pt2; */
44.     //声明了常量数据成员，不能进行常规意义的赋值操作
45.     pt1.print();
46.     pt2.print();
47.     pt3.print();
48.     pt4.print();
49. }
51. int main(void)
52. {
53.     test();
54.     return 0;
55. }

复制代码

 003object.cc

2. #include <iostream>
3. using std::cout;
4. using std::endl;
6. class Point{
7. public:
8.     Point()
9.         :_ix(0),_iy(0)
10.         {cout<<"Point()"<<endl;}
11.     Point(int x=1,int y=1)
12.         :_ix(x),_iy(y) //const int _ix=x;
13.         {cout<<"Point(int ,int)"<<endl;}
14.     Point(const Point & p)
15.         :_ix(p._ix),_iy(p._iy)
16.         {cout<<"Point(Point &)"<<endl;}
17.     ~Point(){cout<<"~Point()"<<endl;}
18.     void print(){ cout<<_ix<<" "<<_iy; }
19. private:
20.     int _ix;
21.     int _iy;
22. };
24. class Line{
25. public:
26.     Line(int x1,int y1,int x2,int y2)
27.         :_pt1(x1,y1),_pt2(x2,y2)
28.         /* :_pt1(),_pt2() */
29.          //搞不懂啊啊啊,为撒不初始化的不行喵，创建worning,打印error
30.          //LIne的构造函数的初始化列表中
31.          //需要显示调用point的构造完成对象成员的初始化
32.          //如果没有，编译器自动调用POINT的无参构造
33.          //活着所有参数都有默认值的有参构造
34.         {cout<<"Line(int*4)"<<endl;}
35.     ~Line(){cout<<"~line"<<endl;}
36.     void printLine(){
37.         _pt1.print();
38.         cout<<"---->";
39.         _pt2.print();
40.         cout<<endl;
41.     }
42. private:
43.          Point _pt1;
44.          Point _pt2;
45. };
47. void test(){
48.     Line l(1,2,3,4);
49.     l.printLine();
50.     /* Line l1(); */
51.     /* l1.printLine(); */
52. }
54. int main(void)
55. {
56.     test();
57.     return 0;
58. }

复制代码

04_static_member.cc 

2. #include <iostream>
3. #include <string.h>
4. using std::cout;
5. using std::endl;
7. class Computer{
8. public:
9.     /* void init(const char* brand,int price){ */
10.     /*     strcpy(_brand,brand); */
11.     /*     _price=price; */
12.     /* } */
13.     void printBrandPrice(){
14.         cout<<_brand<<"\t";
15.         cout<<_price<<endl;
16.     }
17.     static int get_totalprice(){
18.         return _totalprice;
19.     }
20. //----------------------------//
21. /* private: */
22.     Computer(const char* brand,int price)
23.         : _brand(new char[strlen(brand)+1]())
24.         , _price(price)
25.     {
26.         strcpy(_brand,brand);// 否则没有赋值喵，不输出
27.         _totalprice+=_price;
28.        cout<<_brand<<"\t\t"<<"Computer(char* int)"<<endl;
29.     }
30.     Computer(const Computer & c)
31.         : _brand(new char[strlen(c._brand)+1]())
32.         , _price(c._price)
33.     {
34.         strcpy(_brand,c._brand);// 否则没有赋值喵，不输出
35.         _totalprice+=_price;
36.        cout<<"Computer(cosnt Computer &)"<<endl;
37.     }
38.     Computer & operator=(const Computer & c){
39.         if(this!=&c){
40.             delete [] _brand;
41.             _brand=new char[strlen(c._brand)+1]();
42.             strcpy(_brand,c._brand);
43.             _price=c._price;
44.             _totalprice+=_price;
45.         }
46.         return *this;
47.     }
48. //----------------------------//
49.     ~Computer(){
50.         cout<<_brand<<"\t\t";
51.         if(_brand){
52.             delete  _brand;  //coution
53.              _brand=nullptr;   //加上，信任行为喵
54.             _totalprice-=_price;
55.         }
56.         cout<<"~Computer"<<endl;
57.     }
58. private:
59.     char* _brand;
60.     int _price;
61.     static int  _totalprice;
62. };
63. int Computer::_totalprice=0;
65. //----------------------------//
66. void test(){
67.     cout<<sizeof(Computer)<<endl;
68.     cout<<Computer::get_totalprice()<<endl;
69.     Computer p1("xixi",66);
70.     cout<<p1.get_totalprice()<<endl;
71.     Computer p2("paxi",66);
72.     cout<<p1.get_totalprice()<<endl;
73. }
74. int main(void)
75. {
76.     test();
77.     return 0;
78. }

复制代码

05_constMember.cc

2. #include <iostream>
3. #include <string.h>
4. using std::cout;
5. using std::endl;
7. class Computer{
8. public:
9.     void init(int price)/*const*/{
10.         _price=price;
11.     }
12.     void printBrandPrice()const{
13.         cout<<_brand<<"\t";
14.         cout<<_price<<"\tconst_print"<<endl;
15.     }
16. //----------------------------//
17. /* private: */
18.     Computer(const char* brand,int price)
19.         : _brand(new char[strlen(brand)+1]())
20.         , _price(price)
21.     {
22.         strcpy(_brand,brand);// 否则没有赋值喵，不输出
23.        cout<<_brand<<"\t\t"<<"Computer(char* int)"<<endl;
24.     }
25.     Computer(const Computer & c)
26.         : _brand(new char[strlen(c._brand)+1]())
27.         , _price(c._price)
28.     {
29.         strcpy(_brand,c._brand);// 否则没有赋值喵，不输出
30.        cout<<"Computer(cosnt Computer &)"<<endl;
31.     }
32.     Computer & operator=(const Computer & c){
33.         if(this!=&c){
34.             delete [] _brand;
35.             _brand=new char[strlen(c._brand)+1]();
36.             strcpy(_brand,c._brand);
37.             _price=c._price;
38.         }
39.         return *this;
40.     }
41. //----------------------------//
42.     ~Computer(){
43.         cout<<_brand<<"\t\t";
44.         if(_brand){
45.             delete  _brand;  //coution
46.              _brand=nullptr;   //加上，信任行为喵
47.         }
48.         cout<<"~Computer"<<endl;
49.     }
50. private:
51.     char* _brand;
52.     int _price;
53. };
55. //----------------------------//
56. void test(){
57.     cout<<sizeof(Computer)<<endl;
58.     Computer p1("xixi",66);
59.     p1.init(7888);
60.     //不能修改对象的数据成员
61.     p1.printBrandPrice();
63.     cout<<endl;
64.     const Computer p2("paxi",66);
65.     p2.printBrandPrice();
66.     /* p2.init(7888); */
68.     cout<<endl;
69. }
70. int main(void)
71. {
72.     test();
73.     return 0;
74. }

复制代码

06_constfuction.cc

2. #include <iostream>
3. #include <string.h>
4. using std::cout;
5. using std::endl;
7. class Computer{
8. public:
9.     void init(int price)/*const*/{
10.         _price=price;
11.     }
12.     void printBrandPrice(const Computer & c)const{
13.         /* for(int i=0;i<strlen(c._brand)+1;i++){ */
14.         /*     _brand[i]=c._brand[i]; */
15.         /* } */
16.         //尽量避免
17.         cout<<_brand<<"\t";
18.         cout<<_price<<"\tconst_print"<<endl;
19.     }
20.     //----------------------------//
21.     /* private: */
22.     Computer(const char* brand,int price)
23.         : _brand(new char[strlen(brand)+1]())
24.           , _price(price)
25.     {
26.         strcpy(_brand,brand);// 否则没有赋值喵，不输出
27.         cout<<_brand<<"\t\t"<<"Computer(char* int)"<<endl;
28.     }
29.     Computer(const Computer & c)
30.         : _brand(new char[strlen(c._brand)+1]())
31.           , _price(c._price)
32.     {
33.         strcpy(_brand,c._brand);// 否则没有赋值喵，不输出
34.         cout<<"Computer(cosnt Computer &)"<<endl;
35.     }
36.     Computer & operator=(const Computer & c){
37.         if(this!=&c){
38.             delete [] _brand;
39.             _brand=new char[strlen(c._brand)+1]();
40.             /* strcpy(_brand,c._brand); */
41.             _price=c._price;
42.         }
43.         return *this;
44.     }
45.     //----------------------------//
46.     ~Computer(){
47.         cout<<_brand<<"\t\t";
48.         if(_brand){
49.             delete  _brand;  //coution
50.             _brand=nullptr;   //加上，信任行为喵
51.         }
52.         cout<<"~Computer"<<endl;
53.     }
54. private:
55.     /* const char* _brand;//+brand[]也不行，只读变量不可赋值 */
56.     char* _brand;
57.     int _price;
58. };
60. //----------------------------//
61. void test(){
62.     Computer p1("xixi",66);
63.     Computer p2("kaixin",66);
64.     p1.printBrandPrice(p2);
65.     cout<<endl;
66. }
67. int main(void)
68. {
69.     test();
70.     return 0;
71. }

复制代码

07_PointArray.cc

2. #include <iostream>
3. using std::cout;
4. using std::endl;
6. class Point{
7. public:
8.     Point()
9.         :_ix(0),_iy(0)
10.         {cout<<"Point()"<<endl;}
11.     Point(int x/*=1*/,int y=1)
12.         :_ix(x),_iy(y) //const int _ix=x;
13.         {cout<<"Point(int ,int)"<<endl;}
14.     Point(const Point & p)
15.         :_ix(p._ix),_iy(p._iy)
16.         {cout<<"Point(Point &)"<<endl;}
17.     ~Point(){cout<<"~Point()"<<endl;}
18.     Point & operator=(const Point & p){
19.         _ix=p._ix;_iy=p._iy;
20.         return *this;
21.     }
22.     void print(){ cout<<_ix<<" "<<_iy<<endl; }
23. private:
24.     int _ix;
25.     int _iy;
26. };
28. void test(){
29.     Point* p1=new Point(3,4);
30.     p1->print();
32.     (*p1).print();
33.     delete p1;
34.    
35.     //()确保进行了初始化，初始化为相应类信息的默认值
36.     int *p=new int();
37.     cout<<*p<<endl;
38.     delete p;
40.     //Point 类型的默认值是无参构造初始化的Point对象
41.     Point* p2=new Point();//调用模糊
42.     p2->print();
43.     delete p2;
45.     //------------------------------//
46.     cout<<endl;
48.     Point p4(7,5);
49.     Point p3(3,5);
50.     Point p6(6,5);
52.     Point arr[3]={p4,p3,p6};//Point(const Point &)
53.     cout<<&p4<<endl;
54.     cout<<arr<<endl;
55.     cout<<endl;
57.     Point ar1[2]={Point(1,2),Point(3,4)};
58.     ar1[0].print();
59.     (ar1+1)->print();
60.     cout<<endl;
62.     Point ar2[2]={{2,2},{5,5}};
63. }
65. int main(void)
66. {
67.     test();
68.     return 0;
69. }

复制代码

08_Student.cc

2. #include <iostream>
3. #include <string.h>
4. using std::cout;
5. using std::endl;
7. class Student
8. {
9. public:
10.         Student(int id, const char * name)
11.         : _id(id)
12.         , _name(new char[strlen(name) + 1]())
13.         {
14.                 strcpy(_name, name);
15.                 cout << "Student()" << endl;
16.         }
17.         ~Student(){
18.         if(_name){
19.             delete [] _name;
20.             _name = nullptr;
21.         }
22.         }
23.     //------------------------------//
24.     void operator delete(void * pointer){
25.         cout<<"operator delete"<<endl;
26.         free(pointer);
27.     }
28.     void* operator new(size_t sz){
29.         cout<<"operator new "<<endl;
30.         void* ret=malloc(sz);
31.         return ret;
32.     }
33.     //------------------------------//
34.         void print() const{
35.                 cout << "id:" << _id << "\t"<< "name:" << _name << endl;
36.         }
37. private:
38.         int _id;
39.         char * _name;
40. };
42. //------------------------------//
43. void test(){
44.     Student * s=new Student(3,"xixi");
45.     s->print();
46.     delete s;
47. }
49. int main(void)
50. {
51.     test();
52.     return 0;
53. }

复制代码

09_HeapStudent.cc

2. #include <iostream>
3. #include <string.h>
4. using std::cout;
5. using std::endl;
7. class Student
8. {
9. public:
10.         Student(int id, const char * name)
11.         : _id(id)
12.         , _name(new char[strlen(name) + 1]())
13.         {
14.                 strcpy(_name, name);
15.                 cout << "Student()" << endl;
16.         }
17.         ~Student(){
18.         if(_name){
19.             delete [] _name;
20.             _name = nullptr;
21.         }
22.         }
23.     //------------------------------//
24.     void operator delete(void * pointer){
25.         cout<<"operator delete"<<endl;
26.         free(pointer);
27.     }
28.     void* operator new(size_t sz){
29.         cout<<"operator new "<<endl;
30.         void* ret=malloc(sz);
31.         return ret;
32.     }
33.     void destroy(){
34.         delete this;
35.     }
36.     //------------------------------//
37.         void print() const{
38.                 cout << "id:" << _id << "\t"<< "name:" << _name << endl;
39.         }
40. private:
41.         int _id;
42.         char * _name;
43. };
45. //------------------------------//
46. void test(){
47.     Student * s=new Student(3,"xixi");
48.     s->print();
49.     s->destroy();
50.     /* delete s; */
51. }
53. int main(void)
54. {
55.     test();
56.     return 0;
57. }

复制代码

10_StackStudent.cc

2. #include <iostream>
3. #include <string.h>
4. using std::cout;
5. using std::endl;
7. class Student
8. {
9. public:
10.         Student(int id, const char * name)
11.         : _id(id)
12.         , _name(new char[strlen(name) + 1]())
13.         {
14.                 strcpy(_name, name);
15.                 cout << "Student()" << endl;
16.         }
17.         ~Student(){
18.         if(_name){
19.             delete [] _name;
20.             _name = nullptr;
21.         }
22.         }
23.         void print() const{
24.                 cout << "id:" << _id << "\t"<< "name:" << _name << endl;
25.         }
26. private:
27.     //------------------------------//
28.     void operator delete(void * pointer){
29.         cout<<"operator delete"<<endl;
30.         free(pointer);
31.     }
32.     void* operator new(size_t sz){
33.         cout<<"operator new "<<endl;
34.         void* ret=malloc(sz);
35.         return ret;
36.     }
37.     void destroy(){
38.         delete this;
39.     }
40.     //------------------------------//
41. private:
42.         int _id;
43.         char * _name;
44. };
46. //------------------------------//
47. void test(){
48.     /* Student * s=new Student(3,"xixi"); */
49.     Student s(3,"xix");
50.     s.print();
51.     /* s.destroy(); */
52.     /* delete s; */
53. }
55. int main(void)
56. {
57.     test();
58.     return 0;
59. }

复制代码

static_single.cc

2. #include <iostream>
3. using std::cout;
4. using std::endl;
6. class Point{
7. public:
8.     Point()
9.         :_ix(0),_iy(0)
10.         {cout<<"Point()"<<endl;}
11.     /* Point(const Point & p) */
12.     /*     :_ix(p._ix),_iy(p._iy) */
13.     /*     {cout<<"Point(Point &)"<<endl;} */
14.     //删除  拷贝构造效果更好？？？？？
15.     //删除  赋值构造效果更好？？？？？
16.     void print(){ cout<<_ix<<"\t\t"<<_iy<<endl; }
17.     static Point & getInstance(){
18.         static Point pt(2,8);
19.         //单例模式，只能初始化一次
20.         return pt;
21.     }//不是静态成员函数？？？
22. private:
23.     Point(int x,int y=1)
24.         :_ix(x),_iy(y)
25.         {cout<<"Point(int ,int)"<<endl;}
26.     //构造  私有
27.     ~Point(){
28.         cout<<"~Point()"<<endl;
29.     }
30.     //析构  私有（四大金刚全部干掉喵
31. private:
32.     int _ix;
33.     int _iy;
34. };
36. void test(){
37.     Point & pt1=Point::getInstance();
38.     Point & pt2=Point::getInstance();
39.     cout<<&pt1<<endl;
40.     cout<<&pt2<<endl;
41. }
43. int main(void)
44. {
45.     test();
46.     return 0;
47. }

复制代码

heap_single.cc 

2. #include <iostream>
3. using std::cout;
4. using std::endl;
6. //堆上创建单例对象
7. class Point{
8. public:
9.     static Point * getInstance(){
10.         if(_pInstance==nullptr){
11.             _pInstance=new Point(1,2);
12.         }
13.         return _pInstance;
14.     }
15.     static void destroy(){
16.         if(_pInstance){
17.             delete _pInstance;
18.             _pInstance=nullptr;
19.         }
20.         cout<<"<<<delete heap"<<endl;
21.     }
22.     //C++11之后可以将成员函数从类中删除
23.     Point(Point & rhs)=delete;
24.     Point & operator=(const Point & rhs)=delete;
25.     void init(int x,int y){
26.         _ix=x;_iy=y;
27.     }//初始化和赋值分开
28.     void print(){ cout<<_ix<<"\t\t"<<_iy<<endl; }
29. private:
30.     Point()
31.         :_ix(0),_iy(0)
32.         {cout<<"Point()"<<endl;}
33.     Point(int x,int y)
34.         :_ix(x),_iy(y) //const int _ix=x;
35.         {cout<<"Point(int ,int)"<<endl;}
36.     ~Point(){cout<<"~point()"<<endl;}
37. private:
38.    int _ix;
39.    int _iy;
40.    static Point* _pInstance;
41.    //定义一个指针保存第一次创建的对象
42. };
43. Point * Point::_pInstance=nullptr;
44. //初始化
46. void test(){
47.     //使用规范，避免多个指针拥有单例对象的管理权
48.     Point::getInstance()->print();
49.     Point::getInstance()->init(21,13);
50.     Point::getInstance()->print();
51.     Point::getInstance()->init(23,231);
52.     Point::getInstance()->print();
53.     Point::destroy();
54.     Point::destroy();
55.     Point::destroy();
56.     //多次执行也不会有double free的问题
57.     Point::getInstance()->print();
58.     Point::destroy();
59. }
61. int main(void)
62. {
63.     test();
64.     return 0;
65. }

复制代码

06 作业

01，特殊的成员函数有哪几种？各自的特点是什么？ （坏，答了一个特殊的数据成员

1，static成员函数
0.1 静态成员函数不依赖于某一对象
0.2 静态成员函数可以通过对象调用，但更加常见的方式是通过类名加上作用域限定符调用
0.3 静态成员函数没有this指针
0.4 静态成员函数中无法直接利用成员名访问非静态的成员，只能访问静态数据成员或调用静态成员（由于没有this指针），但好坏静态的成员函数可以访问静态成员
0.5 构造/析构/赋值运算符/拷贝构造比力特殊，可以在静态成员函数中调用（这四个函数不能设置为静态成员函数，他们会访问全部的成员对象，但是静态成员函数没有this指针）
2，const成员函数
0.1 cosnt 成员函数中，不能修改对象的数据成员
0.2 当编译器发现该函数是const成员函数时，会主动将this指针设置为双重const限定的指针
const 对象与const 成员函数的规则：
当类中有const成员函数和非const成员函数重载时，const对象会调用const成员函数，非const对象会调用非const成员函数
当类中只有一个const成员函数时，无论const对象还好坏const对象都可以调用这个版本
当类中只有一个非const成员函数时，const对象就不能调用非const版本
总结：假如一个成员函数中确定不会修改数据成员，就把它界说为const成员函数
02，写出以下步伐运行的结果。（ ）

2. class Sample
3. {
4. public:
5.       Sample();
6.       void Display();
7. private:
8.       int i;
9.       static int k;
10. };
12. Sample::Sample()
13. {
14.         i=0;
15.         k++;
16. }
18. void Sample::Display()
19. {
20.    cout << "i=" << i << ",k=" << k << endl;
21. }
23. int Sample::k=0;
25. int main( )
26. {
27.     Sample a, b;
28.     a.Display();
29.     b.Display();
30.    
31.     return 0;
32. }

复制代码

i=0,k=1（2）坏
i=0,k=2 
03，写出下面步伐的结果：  11

2. #include <iostream>
3. using std::cout;
4. using std::endl;
6. int i = 1;
8. class Test
9. {
10. public:
11.         Test()
12.         :_first(i++) //1  2
13.         ,_second(i++)//2  3
14.         ,_third(i++)//3  4
15.         ,_fourth(_third)//3
17.         {
18.                 _third = i;//4   _foruth=4
19.         }
20.         void print()
21.         {  
22.                 cout << "result : " << _first + _second + _third + _fourth << endl;
23.         //1 2 4 4 =11
24.         }
25. private:
26.         int _first;
27.         int _second;
28.         int _third;
29.         int &_fourth;
30. };
32. int main()
33. {
34.         Test test;
35.         test.print();
36.        
37.         return 0;
38. }

复制代码

04，写出以下步伐运行的结果。

2. #include <iostream>
3. #include <math.h>
4. using std::cout;
5. using std::endl;
7. class Point       
8. {
9. public:
10.     Point(int xx = 0, int yy = 0)
11.         {
12.                 X = xx;
13.                 Y = yy;
14.                 cout << "point构造函数被调用" << endl;
15.         }
16.        
18.            Point(Point &p);
19.           
20.            int GetX()
21.            {
22.                    return X;
23.            }
24.           
25.            int GetY()
26.            {
27.                    return Y;
28.            }
30. private:
31.         int X,Y;
32. };
34. Point::Point(Point &p)       
35. {
36.         X = p.X;
37.         Y = p.Y;
38.         cout << "X = " << X << " Y=" << Y << "Point拷贝构造函数被调用" << endl;
39. }
41. class Distance       
42. {
43. public:       
44.         Distance(Point xp1, Point xp2);
45.         double GetDis()
46.         {
47.                 return dist;
48.         }
49. private:       
50.         Point p1,p2;
51.         double dist;       
52. };
54. //拷贝一次
55. Distance::Distance(Point xp1, Point xp2)
56. : p1(xp1)//拷贝一次
57. , p2(xp2)
58. {
59.         cout << "Distance构造函数被调用" << endl;
60.         double x = double(p1.GetX() - p2.GetX());
61.         double y = double(p1.GetY() - p2.GetY());
62.         dist = sqrt(x * x + y * y);
63. }
65. int main()
66. {
67.     //point构造函数被调用
68.     //point构造函数被调用
69.         Point myp1(1,1), myp2(4,5);
70.     //X=1,Y=1,Point拷贝构造函数被调用
71.     //X=4,Y=5,Point拷贝构造函数被调用
72.     //X=1,Y=1,Point拷贝构造函数被调用
73.     //X=4,Y=5,Point拷贝构造函数被调用
74.         Distance myd(myp1, myp2);
75.     //Distance构造函数被调用
76.         cout << "The distance is:" ;
77.     //The distance is:dist
78.         cout << myd.GetDis() << endl;
79.        
80.         return 0;
81. }

复制代码

point构造函数被调用
point构造函数被调用
X = 4 Y=5Point拷贝构造函数被调用
X = 1 Y=1Point拷贝构造函数被调用
X = 1 Y=1Point拷贝构造函数被调用
X = 4 Y=5Point拷贝构造函数被调用
Distance构造函数被调用
The distance is:5  
05，写出以下步伐运行的结果。   122444

2. #include <iostream>
3. using std::cout;
4. using std::endl;
6. class MyClass
7. {
8. public:
9.     MyClass(int i = 0)
10.     {
11.         cout << i;
12.     }
13.     MyClass(const MyClass &x)
14.     {
15.         cout << 2;
16.     }
17.     MyClass &operator=(const MyClass &x)
18.     {
19.         cout << 3;
20.         return *this;
21.     }
22.     ~MyClass()
23.     {
24.         cout << 4;
25.     }
26. };
27. int main()
28. {
29.     MyClass obj1(1), obj2(2);
30.     //12
31.     MyClass obj3 = obj1;//==Myclass obj3(obj1);
32.     //32444
33.     return 0;
34. }

复制代码

06，不思量任何编译器优化(如:NRVO),下述代码的第10#会发生-fno-elide-constructors 编译时消除优化的影响

2. #include <iostream>
3. using std::cout;
4. using std::endl;
6. class B
7. {
8. public:
9.         B()
10.         {
11.         cout << "B()" << endl;
12.     }
14.     ~B()
15.     {
16.             cout << "~B()" << endl;
17.     }
18.    
19.     B(const B &rhs)
20.     {
21.         cout << "B(const B&)" << endl;
22.     }
23.    
24.     B &operator=(const B &rhs)
25.     {
26.             cout << "B &operator=(const B &s)" << endl;
27.    
28.         return  *this;
29.     }
30. };
32. B func(const B &rhs)
33.     //cp  不是喵是赋值
34. {
35.     cout << "B func(const B &)" << endl;
36.     return rhs;
37. }
39. int main(int argc, char **argv)
40. {
41.         B b1,b2;
42.     b2=func(b1);//10#
43.                 //B func(const B &)
44.                 //B(const B&)
45.                 //B &operator=(const B &s)
47.         return 0;
48. }

复制代码

B func(const B &)
B(const B&)
B &operator=(const B &s) 
07，new表达式和delete表达式的底层实现是什么？

1，对于自界说范例而言
利用new表达式的三个步调：
1，调用operator new尺度库函数申请未范例化的空间
2，在该空间上调用该范例的构造函数初始化对象
3，返回指向该对象的相应范例的指针
利用delete表达式···
1，调用析构函数，采取数据成员申请的资源（堆空间）
2，调用operator delete库函数采取本对象所在的空间
对于内置范例而言，则没有以上构造函数和析构函数实行的步调
08，实现单例的Point类（将单例对象创建在堆上）

heap_single.cc 
09，实现一个单例的Computer类，包罗品牌和代价信息。

2. #include <iostream>
3. #include <string.h>
4. using std::cout;
5. using std::endl;
7. class Computer{
8. public:
9.     static Computer * get(){
10.         if(!_pp){
11.            _pp=new Computer("xixi",520);
12.         }
13.         return _pp;
14.     }
15.     /* void* operator new(size_t sz){ */
16.     /*     void * ret=malloc(sz); */
17.     /*     return ret; */
18.     /* } */
19.     /* void operator delete(void * p){ */
20.     /*     free(p); */
21.     /* } */
22.     static void destory(){
23.         if(_pp){
24.             delete _pp;
25.             _pp=nullptr;
26.         }
27.         cout<<"<<<< destory"<<endl;
28.     }
29.     Computer(Computer & c)=delete;
30.     Computer & operator=(const Computer & c)=delete;
31.     void init(const char* brand,int price){
32.         strcpy(_brand,brand);
33.         _price=price;
34.     }
35.     void printBrandPrice(){
36.         cout<<_brand<<"\t";
37.         cout<<_price<<endl;
38.     }
39. private:
40.     Computer(const char* brand,int price)
41.         : _brand(new char[strlen(brand)+1]())
42.         , _price(price)
43.     {
44.         strcpy(_brand,brand);// 否则没有赋值喵，不输出
45.        cout<<_brand<<"\t\t"<<"Computer"<<endl;
46.     }
47.     ~Computer(){
48.         cout<<_brand<<"\t\t";
49.         if(_brand){
50.             delete  _brand;  //coution
51.              _brand=nullptr;   //加上，信任行为喵
52.         }
53.         cout<<"~Computer"<<endl;
54.     }
55. private:
56.     char* _brand;
57.     int _price;
58.     static Computer * _pp;
59. };
60. Computer*Computer::_pp=nullptr;
62. void test(){
63.     Computer::get()->printBrandPrice();
64.     Computer::get()->init("jiajia",7758258);
65.     Computer::get()->printBrandPrice();
66.     Computer::get()->init("yueyue",51930);
67.     Computer::get()->printBrandPrice();
68.     Computer::destory();
69.     Computer::destory();
70.     Computer::destory();
71. }
72. void test01(){
73. }
74. int main(void)
75. {
76.     test();
77.     test01();
78.     return 0;
79. }

复制代码