1.构造函数
类的初始化即为构造函数。也为：隐式的初始化。
构造函数在对象初始化的时候，自动被调用。隐式的调用。
构造函数分为三种：有参构造函数、无参构造函数、拷贝构造函数。
有参构造函数调用有三种：括号法、等号法、手工法。
#include <iostream>
using namespace std;
class Test
{
private:
int m_a;
public:
Test()//无参构造函数
{ }
Test(const Test &obj)//拷贝构造函数
{ }
Test(int a)//有参构造函数
{
m_a = a;
}
void print()
{
cout << "m_a:" << m_a << endl;
}
};
void main()
{
Test t1(10);//括号法 //c++编译器自动调用这个类的有参构造函数
t1.print();
Test t2 = 20;//等号法 //c++编译器自动调用这个类的有参构造函数
t2.print();
Test t3 = Test(30);//手工法 //程序员手工的调用构造函数 进行对象初始化
t3.print();
system("pause");
}
2.析构函数
析构函数(destructor) 与
构造函数
相反，当
对象
脱离其
作用域
时（例如对象所在的函数已调用完毕），系统自动执行析构函数。析构函数往往用来做“清理善后” 的工作（例如在建立
对象
时用new开辟了一片内存空间，应在退出前在析构函数中用delete释放）。
主函数结束的同时，对象stud1，stud2均应被“清理”，而清理就是通过调用了析构函数实现的。
#define _CRT_SECURE_NO_WARNINGS
#include<string>
#include<iostream>
using namespace std;
class stud//声明一个类
{
private://私有部分
int num;
char name[10];
char sex;
public://公用部分
stud(int n, char nam[], char s)//构造函数
{
num = n;
strcpy(name, nam);
sex = s;
}
~stud()//析构函数
{
cout << "stud has been destructed!" << endl;//通过输出提示告诉我们析构函数确实被调用了
}
void display()//成员函数
{
cout << "num:" << num << endl;
cout << "name:" << name << endl;
cout << "sex:" << sex << endl;
}
};
int main()
{
stud stud1(10010, "Wang-li", 'f');
stud stud2(10011, "Zhang-fun", 'm');//建立两个对象
stud1.display();//输出学生1的数据
stud2.display();//输出学生2的数据
system("pause");
return 0;
}
3.拷贝构造函数
拷贝构造函数，是一种特殊的构造函数，它由编译器调用来完成一些基于同一类的其他对象的构建及初始化。其唯一的形参必须是引用，但并不限制为const，一般普遍的会加上const限制。此函数经常用在函数调用时用户定义类型的值传递及返回。拷贝构造函数要调用基类的拷贝构造函数和成员函数。如果可以的话，它将用常量方式调用，另外，也可以用非常量方式调用。
当我们没有编写拷贝构造函数的时候，c++编译器会默认给我们提供一个拷贝构造函数，执行的是浅拷贝。
copy构造函数四种应用场景；
第一种场景：=
#include <iostream>
using namespace std;
class CExample {
private:
int a;
public:
//构造函数
CExample(int b)
{
a = b;
}
//拷贝构造函数
CExample(const CExample& C)
{
a = C.a;
}
//一般函数
void Show()
{
cout << a << endl;
}
};
int main()
{
CExample A(100);
CExample B = A; //注意这里的对象初始化要调用拷贝构造函数,而非赋值
// CExample B(A); 也是一样的
B.Show();
return 0;
}
第二种场景：（）
#include <iostream>
using namespace std;
class CExample {
private:
int a;
public:
//构造函数
CExample(int b)
{
a = b;
}
//拷贝构造函数
CExample(const CExample& C)
{
a = C.a;
}
//一般函数
void Show()
{
cout << a << endl;
}
};
int main()
{
CExample A(100);
//CExample B = A; //注意这里的对象初始化要调用拷贝构造函数,而非赋值
CExample B(A); //也是一样的
B.Show();
return 0;
}
第三种场景：对象以值传递的方式传入函数参数
#include <iostream>
using namespace std;
class CExample
{
private:
int a;
public:
//构造函数
CExample(int b)
{
a = b;
cout << "creat: " << a << endl;
}
//拷贝构造
CExample(const CExample& C)
{
a = C.a;
cout << "copy" << endl;
}
//析构函数
~CExample()
{
cout << "delete: " << a << endl;
}
void Show()
{
cout << a << endl;
}
};
//全局函数,传入的是对象
void g_Fun(CExample C)
{
cout << "test" << endl;
}
int main()
{
CExample test(1);
//传入对象
g_Fun(test);
return 0;
}
第四种场景：对象以值传递的方式从函数返回
#include <iostream>
using namespace std;
class CExample
{
private:
int a;
public:
//构造函数
CExample(int b=0)
{
a = b;
cout << "a:" << a << endl;
}
~CExample()
{
cout << "destroy a:" << a << endl;
}
//拷贝构造
CExample(const CExample& C)
{
a = C.a;
cout << "copy a:"<< a << endl;
}
};
//全局函数
CExample g_Fun()
{
CExample temp(10);
return temp;
}
int main()
{
CExample ret;
ret = g_Fun();
return 0;
} 添加断点，逐条语句运行，观察程序的执行步骤以及打印输出：
4.深copy浅copy
在某些状况下，类内成员变量需要动态开辟堆内存，如果实行位拷贝，也就是把对象里的值完全复制给另一个对象，如A=B。这时，如果B中有一个成员变量指针已经申请了内存，那A中的那个成员变量也指向同一块内存。这就出现了问题：当B把内存释放了（如：析构），这时A内的指针就是野指针了，出现运行错误。
深拷贝和浅拷贝可以简单理解为：如果一个类拥有资源，当这个类的对象发生复制过程的时候，资源重新分配，这个过程就是深拷贝，反之，没有重新分配资源，就是浅拷贝。
#include "iostream"
using namespace std;
class name
{
public :
name(char *pn) ;
name( name &obj)
{
cout <<" copy Constructing " << endl ;
char *pn = obj.getPn();
pname = (char *)malloc(strlen(pn) +1);
if (pname!=NULL) strcpy(pname,pn) ;
//pname = new char[strlen(pn)+1] ;
//if (pname!=0) strcpy(pname,pn) ;
size = strlen(pn) ;
}
~ name() ;
protected :
char *pname ; int size ;
public:
char * getPn()
{
return pname;
}
void operator=(name &obj1)
{
cout <<" 执行=操作" << endl ;
char *pn = obj1.getPn();
pname = (char *)malloc(strlen(pn) +1);//此处malloc了内存，没有free，存在一个潜在的bug
if (pname!=NULL) strcpy(pname,pn) ;
//pname = new char[strlen(pn)+1] ;
//if (pname!=0) strcpy(pname,pn) ;
pname[0] = 'm';
size = strlen(pn) ;
}
} ;
name::name(char *pn)
{
cout <<" Constructing " << pn << endl ;
pname = (char *)malloc(strlen(pn) +1);
if (pname!=0) strcpy(pname,pn) ;
//pname = new char[strlen(pn)+1] ;
//if (pname!=0) strcpy(pname,pn) ;
size = strlen(pn) ;
}
name :: ~ name()
{
cout << " Destructing " << pname << endl ;
pname[0] = '\0' ;
//delete []pname ;
free(pname);
size = 0 ;
}
void playmain()
{
name obj1("name1");
//如果你不写copy构造函数，那么C++编译器会给我们提供一个默认的copy构造函数 （浅cpy）
name obj2 = obj1;
//如果你不写=操作，那么C++编译器会给我们提供一个=操作函数 （浅cpy）
obj2 = obj1;
cout<<obj2.getPn()<<endl;
}
void main()
{
playmain();
system("pause");
}
#define _CRT_SECURE_NO_WARNINGS
#include "iostream"
using namespace std;
class name
{
public:
name(char *pn);
name(name &obj)
{
cout << " copy Constructing " << endl;
char *pn = obj.getPn();
pname = (char *)malloc(strlen(pn) + 1);
if (pname != NULL) strcpy(pname, pn);
//pname = new char[strlen(pn)+1] ;
//if (pname!=0) strcpy(pname,pn) ;
size = strlen(pn);
}
~name();
protected:
char *pname; int size;
public:
char * getPn()
{
return pname;
}
void operator=(name &obj1)
{
cout << " 执行=操作" << endl;
if (pname != NULL)//此处有一个疑问：如果不free， 直接将原来的内存进行重新赋值
{
char *pn = obj1.getPn();
strcpy(pname, pn);
pname[0] = 'N';
size = strlen(pn);
}
}
/*
void operator=(name &obj1)
{
cout <<" 执行=操作" << endl ;
if (pname != NULL)//此处有一个疑问：如果不free， 直接将原来的内存进行重新赋值
{
free(pname);
pname = NULL;
size = 0;
}
char *pn = obj1.getPn();
pname = (char *)malloc(strlen(pn) +1);
if (pname!=NULL) strcpy(pname,pn) ;
//pname = new char[strlen(pn)+1] ;
//if (pname!=0) strcpy(pname,pn) ;
pname[0] = 'm';
size = strlen(pn) ;
}
*/
};
name::name(char *pn)
{
cout << " Constructing " << pn << endl;
pname = (char *)malloc(strlen(pn) + 1);
if (pname != 0) strcpy(pname, pn);
//pname = new char[strlen(pn)+1] ;
//if (pname!=0) strcpy(pname,pn) ;
size = strlen(pn);
}
name :: ~name()
{
cout << " Destructing " << pname << endl;
pname[0] = '\0';
//delete []pname ;
free(pname);
size = 0;
}
int playmain()
{
name obj1("name1");
name obj3("name3");
//如果你不写copy构造函数，那么C++编译器会给我们提供一个默认的copy构造函数 （浅cpy）
name obj2 = obj1;
//做业务逻辑
//此处省略500行
//如果你不写=操作，那么C++编译器会给我们提供一个=操作函数 （浅cpy）
//会调用对象2 的=号操作函数， obj3是形参， obj2干什么去了？
obj2 = obj3;
cout << obj2.getPn() << endl;
return 0;
}
int main()
{
playmain();
//system("pause");
return 0;
}
最终分析图：
