构造函数调用规则
默认情况下，C++编译器至少给类添加3个函数
1、默认构造函数（无参，函数体 为空）；
2、默认析构函数（无参，函数体 为空）；
3、默认拷贝构造函数，对属性进行值拷贝。
1、如果用户定义有参构造函数，C++不再提供默认无参构造函数，但会提供默认拷贝构造函数；
2、如果用户定义拷贝构造函数，C++不会再提供其他构造函数。
拷贝构造函数的使用规则
include
using namespace std;
class to
{
public:
to()
{
printf("构造\n");
}
~to()
{
printf("析构\n");
}
to(const to& q)
{
printf("拷贝构造\n");
}
};
void func(to a)
{
}
void test2()
{
//已有的对象去初始化另一个对象
to we;
to t1(we);
}
to func2()
{
//局部对象
to z;
return z;
}
int main()
{
func2();
}
2.多个对象的析构 和构造
include
using namespace std;
class to1
{
public:
to1(int a)
{
printf("构造1\n:%d",a);
}
~to1()
{
printf("析构1\n");
}
to1(const to1& q)
{
printf("拷贝构造1\n");
}
};
class to2
{
public:
to2(int c)
{
printf("构造2\n");
}
~to2()
{
printf("析构2\n");
}
to2(const to2& q)
{
printf("拷贝构造2\n");
}
};
class to3
{
public:
to3():eq(3), e(4)
{
printf("拷贝构造3\n");
}
to2 e;
to1 eq;
};
int main()
{
to3 eqq;
}
3.深浅拷贝
浅拷贝
include
using namespace std;
class to
{
public:
int c=0;
to(int a)
{
c = a;
printf("构造1\n:%d",c);
}
~to()
{
printf("析构1\n");
}
};
int main()
{
to eqq(3);
to eqq2(eqq);
}
默认拷贝问题
class to
{
public:
int c=0;
char* pname;
to(const char* a,int age)
{
c = age;
pname = (char*)malloc(strlen(a) + 1);
strcpy(pname, a);
printf("构造:%d %s\n",c, pname);
}
~to()
{
if (pname != NULL)
{
free(pname);
pname = NULL;
}
printf("析构\n");
}
};
int main()
{
to eqq("小草",12);
to eqq2(eqq);
}
int c=EQQ.C;
NAME=EQQ.NAME;
name不为空 free无法二次释放
深拷贝
include
using namespace std;
class to
{
public:
int c=0;
char* pname;
char* zz;
to(const char* a,int age)
{
c = age;
pname = (char*)malloc(strlen(a) + 1);
strcpy(pname, a);
printf("构造:%d %s\n",c, pname);
}
~to()
{
if (pname != NULL)
{
free(pname);
pname = NULL;
}
printf("析构\n");
}
to(const class to& a)
{
pname = (char*)malloc(strlen(a.pname) + 1);
strcpy(pname, a.pname);
c = a.c;
}
};
int main()
{
to eqq("小草",12);//
/*
int c=EQQ.C;
NAME=EQQ.NAME;
*/
to eqq2(eqq);
printf("%s哈哈\n", eqq2.pname);
}
explicit
只能放在构造函数前,构造函数只有一个参数或者其他参数有默认值时
include
using namespace std;
class to
{
public:
explicit to(int n)
{
}
};
int main()
{
to z = 10;//to z(10) 编译器默认优化
}
静态成员
1.静态成员变量的生命周期是整个程序，作用域在类内
2.静态成员变量在类内声明，类外初始化
3.属于类，所有对象共享
4.类 访问 对象访问都可以
class to
{
public:
static int mm;
to(int n)
{
}
};
int to::mm = 100;
int main()
{
printf("%d", to::mm);
}
静态函数只能 访问静态变量
也是每个成员共有的可以类访问
include
using namespace std;
class to
{
public:
static int mm;
int age = 12;
to(int n)
{
}
static void test()
{
printf("%d", mm);//erro
}
};
int to::mm = 100;
int main()
{
to::test();
}