C++学习笔记摘录五.docx

1、C+学习笔记摘录五C+学习笔记SkySeraph 2010-7-31 阅读整理摘自： 接上面 C+学习笔记4继续22：#include using namespace std;class Apublic:A()A(A&one)/这里的函数体的意思是 默认复制构造函数。 n=one.n 是忽略了 this- 指针 编译器会自动加上/this-n=onoe.n m同nn=one.n;/意思是完成成员A的对考 也就是 one 是别名 意思是引用n 的内存地址中的值 m=one.m;/同上A(int i,int j)n=i;m=j;void prt()coutnnmendl;private:int n

2、,m;int main()A a(2,3);a.prt();coutn;A b(a);/这里是复制A对象的值，如果我们没创建构造函数，那么编译器将会自动创建。我们可以看到输出的值/和 a.prt() 是一样的。这就完成了拷贝b.prt();return 0; 23:#include using namespace std;class Apublic:/如果你省略这里的public 那么编译器将会认为他是私有的A()/如果你没设置默认构造函数那么编译器会自动创建一个不带参和无函数体的默认构造函数 比如这个A(int i,int j)n=i;m=j;private:int n,m;24:#incl

3、ude using namespace std;class Apublic:A()cout构造函数执行中.n;A()/如果这里我们不定义 那么 编译器也会给我们创建一个默认析构函数 就是 A() 这种形式 他的函数体为空cout析构函数执行中.n;int main()A *p=new A;/定义一个指向类A的指针P，用来接受类A创建的对象 地址。delete p;/删除p后会自动调用析构函数。主要知识点。也就是delete 会自动调用析构函数return 0;25:#include using namespace std;class Apublic:explicit A(int a)/ exp

4、licit 关键字的意思是 关闭隐式转换，显示转换可以 因为隐式转换容易出问题i=a;cout构造函数执行中.iendl;A()cout析构函数执行中.iendl;void get()coutiendl;private:int i;int main()A b(33);b.get();b=444;/这是简写 这里相当于 b=A(444) 将一个对象用括号括起来，在左边放置一个类型，这个是强制类型表达式/他的右边是一个临时对象，左边是一个对象A， 所以他会执行两次析构函数/A(444) 是调用的 默认构造函数的 A(int a) 他只有一个参数 所以才执行这个 如果多个就必须有相匹配的项目/(44

5、4) 是强制把 444转为对象Areturn 0;/显示转换和隐式转换的区别。显示是 b=A(444) 隐式是 b=44426:#include using namespace std;class Apublic:A()x=new int;*x=5;A()delete x;x=NULL;/删除执行X后吧他赋值为空，避免出错，null 就是空的意思 ，c+中区分大小写A(const A&a)x=a.x;/我们把默认构造函数的这种复制方式叫做成员拷贝 又叫浅拷贝。如果成员里面有指针，/那么这种方式void prt() const cout*xendl;void set(int i)*x=i;pri

6、vate:int *x;int main()A *j=new A();coutprt();coutendl;A b=(*j);b.prt();coutset(22);coutB：;b.prt();coutendl;delete j;/在析构了 j后 内存区域已经被删除 那么b被析构的时候就会找不到那快内存区域 而导致程序崩溃 return 0;27:#include using namespace std;class Apublic:A()x=new int;*x=5;A()delete x;x=NULL;A(const A&a)x=new int;/这两行代码定义了一个新的指针，并把X指向了

7、新的内存空间 *x=*(a.x);/这里他们就不是地址的赋值了，而是值的赋值/以上就是 深层复制构造函数。 他把 旧的指针的值赋值给 新的指针void prt() const cout*xendl;void set(int i)*x=i;private:int *x;int main()A *j=new A();coutprt();coutendl;A b=(*j);/这里是深层赋值，而不是浅层赋值b.prt();coutset(22);coutB：;b.prt();coutendl;delete j;/所以当这里被删除的时候 就不会引起程序崩溃了。因为 j 和b 都是分别指向不同的内存空间

8、。所以J被删除后/不会影响到 b b也不会成为迷途指针return 0;运算符重载.1:#include using namespace std;class Apublic:A()n=1;A()int get() const return n;void set(int x)n=x;private:int n;int main()A a;couta:a.get()endl;/如果这里有 a+ 那么就会出错。因为对象是不能自加的 只有 变量可以return 0;2:#include using namespace std;class Apublic:A()n=1;A()int get() cons

9、t return n;void set(int x)n=x;void add()+n; /在成员函数中进行自加 可以解决上面的问题private:int n;int main()A a;couta:a.get()endl;a.add();/这里就可以通过调用 add函数来实现i的自加couta:a.get()endl;return 0;3:#include using namespace std;class Apublic:A()n=1;A()int get() const return n;void set(int x)n=x;void add()+n; void operator+()/o

10、perator 关键字。可以实现 对象a的自加。他的前面是返回类型 后面是重载运算符 + 就是他要做的事+n;/这里是函数体 才是这个函数所执行的部分，operator 是个函数 所有要加 () 和private:int n;int main()A a;couta:a.get()endl;a.add();couta:a.get()endl;+a;/这里就可以实现a的自加，operator 的作用 就是在这里 。也就是operator 的函数调用 couta:a.get()endl;return 0;/* 为什么上面的功能能够这样实现 。因为 C+中把所有表达式都认为是 operator 比如

11、1+2 那么C+会自动翻译为 operator+(1,2) 然后他会寻找是否有这个默认匹配的参数 会找到operator+(int,int)双int 型同理。其实 +a 的意义就是 i.operator+() operator i+这个就是对象操作操作*/4:#include using namespace std;class Apublic:A()n=1;A()int get() const return n;void set(int x)n=x;void add()+n; A operator+()+n;A t;/创建一个临时对象t.set(n);return t; /返回一个对象Tpri

12、vate:int n;int main()A a;couta:a.get()endl;a.add();couta:a.get()endl;A n=+a;/将自加后的对象赋给另一个对象 由于是对象赋值 所以没有报错 也就是调用 A operator+ 这个函数 并且把 +a 变成3赋值给n/因为 n被初始化为1 后 又被 +n 变成2 然后到 A n=+a +a 又变成3 n就等于3 所以输出3 coutn:n.get()endl;return 0;/这个是解决对象之间的赋值问题，也就是创建临时对象的作用5：#include using namespace std;class Apublic:A

13、()n=1;cout构造函数运行中n; /为了方便查看 所以加上cout 语句A(int i)/创建一个带参数的临时构造函数n=i;cout带参数的构造函数运行中n;/为了方便查看 所以加上cout 语句A()cout析构函数运行中n;/为了方便查看 所以加上cout 语句int get() const return n;void set(int x)n=x;void add()+n; A operator+()+n;return A(n); /这里简化了步骤 直接调用 带参数的默认构造函数 A（N） 来返回给对象A 也就是2private:int n;int main()A a;couta:

14、a.get()endl;a.add();couta:a.get()endl;A n=+a; coutn:n.get()endl;return 0;/以上不创建临时对象而实现对象之间的赋值,但是其实，他是自己创建了一个临时对象，我们的操作只是简化了此步骤而已/通过提示可以看出 带参数的构造函数运行中 在C+中 一旦创建一个对象，那么就会给此对象开辟一个空间， 让他存放此对象/而程序执行完毕也会释放该对象 那么会调用析构函数 6：#include using namespace std;class Apublic:A()n=1;cout构造函数运行中n; A(int i)n=i;cout带参数的构

15、造函数运行中n;A()coutn=s.n;coutn=s.n 可以缩写n=s.n/ const 是定义常量 因为 复制的 s 不会被改变。A&s 就是复制构造函数 ，也就是 s其实就是复制了 A的对象的内存空间地址的值。在上一节中 有讲到int get() const return n;void set(int x)n=x;void add()+n; const A &operator+()/使用CONST指针 定义常量，如果你不想让 下面的 A n=+a 就加上CONST 这样 operator 就会以别名的方式返回源对象，也就是 operator 对象+n;return *this;/这里

16、this 前面要加* 要不然他只是返回一个指针 而不是对象 private:int n;int main()A a;couta:a.get()endl;a.add();couta:a.get()endl;A n=+a;/通过提示文字可以看出，是这里执行的复制构造函数 coutn:n.get()endl;return 0;7:#include using namespace std;class Apublic:A()n=1;cout构造函数运行中n; A(int i)n=i;cout带参数的构造函数运行中n;A()coutn=s.n;cout 已经被省略。 return temp;/返回临时对象

17、 从这里 就是 实现 先返回在自加操作 就是 下面的a+private:int n;int main()A a;couta:a.get()endl;a.add();couta:a.get()endl;A n=a+;couta:a.get()endl;/这里结果为3 后置自加完毕后2+1 等于3 所以这里输出3 coutn:n.get()endl;/从结果中可以看到 n的值为2 因为是后置自加的 所以才会这样 。return 0;/这个就是验证效果的说明！ 也是 重载后置自加运算符8：#include using namespace std;class Apublic:A()n=1;cout构造

18、函数运行中n; A(int i)n=i;cout带参数的构造函数运行中n;A()coutn=s.n;cout复制构造函数执行中.n;int get() const return n;void set(int x)n=x;A add(const A&r)/修改后的ADD函数 这里不在返回无返回值VOID 而是返回一个构造函数A 并且定义A的别名 rreturn A(n+r.get();/返回n+r.get() r.get() 就是上面int get n所返回的值。并且和n 相加 然后在传递给Aconst A &operator+()+n;return *this;const A operator

19、+(int o)A temp(*this);+n; return temp;private:int n;int main()A one(1),two(2),three;/定义三个对象 并且初始化 前两个对象的值。three=one.add(two);/调用方式 已知two是2 one是1 那么 add函数执行就 把2的值传递到r.get() n 是1 那么就是 1+2coutone:one.get()endl;couttwo:two.get()endl;coutthree:three.get()endl;return 0;/这里输出结果/重载加法运算函数 这个例子没有用到 operator 下

20、面才是 方便简单直观的例子：#include using namespace std;class Apublic:A()n=1;cout构造函数运行中n; A(int i)n=i;cout带参数的构造函数运行中n;A()coutn=s.n;cout复制构造函数执行中.n;int get() const return n;void set(int x)n=x;const A operator+(const A&r)/再次修改 只需要把add 换成 operator 即可 并且前面加上 const加上CONST可以防止结果被修改。当然如果你想要修改那么不加 return A(n+r.get();c

21、onst A &operator+()+n;return *this;const A operator+(int o)A temp(*this);+n; return temp;private:int n;int main()A one(1),two(2),three;/three=one.add(two);/ 这里注释掉，如果用operator 使用下面的就更加方便three=one+two; /这样的操作就更加直观了，如果你上面没加常量 那么这里还可以修改为 +(one+two)coutone:one.get()endl;couttwo:two.get()endl;coutthree:three.get()endl;return 0;/重载加法运算函数 这个是运用到 的 是不是更直观？