C++学习（二）

拷贝构造函数 对象1 = 对象2 ：默认的拷贝构造函数

 1 #include <iostream>
 2 using namespace std;
 3 
 4 struct Person{
 5     int age;
 6     string name;
 7 };
 8 
 9 int main(){
10     Person p1 = {10,"张三"};
11     cout << "age: "<<p1.age <<"  name:"<< p1.name << endl;
12     cout << "p1内存地址："<< &p1 << endl;
13     // = 这里是隐式调用：寻找 p1地址对应的成员的值(10，张三) ，寻找p2地址对应的成员，并将值(10，张三) 赋值给它
14     //但是 内存地址已经不是同一个了
15     Person p2 = p1;
16     cout << "p2内存地址："<< &p2 << endl;
17     
18     return 0;
19 }
20 log:
21 age: 6  name:张三
22 p1内存地址：0x7fff1a2db570
23 p2内存地址：0x7fff1a2db5a0

 1 例2：
 2 
 3 #include <iostream>
 4 using namespace std;
 5 
 6 struct Person{
 7     int age;
 8     string name;
 9     Person(){
10     cout << "我是无参构造函数"<< endl;
11     }
12     
13     Person(int age):Person(age,"李四"){
14     cout << "我是1个参数构造函数"<< endl;
15     }
16     Person(int age,string name){
17     cout << "我是2个参数构造函数"<< endl;
18     }
19     
20  //自定义拷贝函数
21     Person(const Person &person){
22     cout << "我是拷贝函数"<< endl;
23     this->age = person.age;
24     this->name = person.name;
25     }
26     ~Person(){
27     cout << "我是析构函数"<< endl;
28     }
29 };
30 
31 int main(){
32     Person p1 = {10,"张三"};
33     Person p2 = p1;
34         
35    //方式2：此种方式不会调用我们自定义的拷贝函数，但是会调用系统默认的拷贝函数
36    Person p2；
37     p2 = p1;
38     
39     return 0;
40 }
41 //log:
42 我是2个参数构造函数
43 我是拷贝函数
44 我是析构函数
45 我是析构函数
46 为何会执行析构函数？答： 此时在栈空间开辟，return时弹栈2次。

 1 #include <iostream>
 2 using namespace std;
 3 
 4 struct Person{
 5     int age;
 6     string name;
 7     Person(){
 8     cout << "我是无参构造函数"<< endl;
 9     }
10     
11     Person(int age):Person(age,"李四"){
12     cout << "我是1个参数构造函数"<< endl;
13     }
14     Person(int age,string name):name(name),age(age){
15     cout << "我是2个参数构造函数"<< endl;
16     }
17     
18     Person(const Person & person){
19     cout << "我是拷贝函数"<< endl;
20     this->age = person.age;
21     this->name = person.name;
22     }
23     ~Person(){
24     cout << "我是析构函数"<< endl;
25     }
26 };
27 
28 int main(){
29     Person *p1 = new Persion(100,"张三");
30     Person *p2 = p1;
31     //此时不会执行拷贝构造函数。
32     //原理： p1 在栈区开辟空间，指向堆区地址0x1000h,它自身也有个内存地址
33     //new Person  在堆区开辟空间，堆存内存地址：0x1000h,
34     // p1 指向 new Persion 堆区对象地址；
35     //p2 指针指向p1地址。
36     //这是指针指向问题。 
37     return 0;
38 }

 1 #include <iostream>
 2 #include "string.h"
 3 using namespace std;
 4 
 5 int main(){
 6     int num =9;
 7     int num2 =10;
 8  //常量指针
 9     const int *  numnew = &num2;
10     //*numnew = 100; 不允许更改 常量指针存放地址的值
11     numnew = &num;//但是可以更改常量指针存放的地址
12     cout << "numnew:" << *numnew << endl;
13     
14     //指针常量
15     int *  const numnew = &num2;
16     *numnew = 100; 允许更改 指针常量存放地址的值
17     //numnew = &num;//不允许更改常量指针存放的地址
18     
19     //常量指针常量则都不允许修改
20     
21    return 0;
22 }

 1 class  Student{
 2     
 3     Student(const Student &stu){
 4         //表示浅拷贝，新地址 name 、 旧地址name 指向同一空间，重复free释放时会报错
 5         this->name = stur.name;
 6         //表示深拷贝，如果有堆成员，必须使用深拷贝
 7         this->name = (char*)malloc(sizeof(char*)*10);
 8         strcpy(this->name,name)
 9     }
10     
11 }

 1 //此处count 1.可以表示循环次数，打印时可通过count打印，
 2 void sum(int  count, ...){
 3     //先定义课表参数的动作
 4     va_list  vp;
 5     //执行完此函数之后 vp就有值了
 6     va_start(vp,count);
 7     //取值，类型是int类型，如果int超限，则返回的是系统值
 8     int number = va_arg(vp,int);
 9     
10     cout << number << endl;
11 }