C++构造函数简单用法
个人笔记，仅供复习
1.构造函数
1.1 基本概念：
- 每个类都有构造函数，如果自己不写，编译器会生成一个默认的无参数构造函数。
- 构造函数名字与类名相同，可以有参数，不可以有返回值（void也不可以）。
- 构造函数的作用是对对象进行初始化，如给变量赋初值。
1.2 注意：
- 如果定义了构造函数，则编译器不生成默认的无参数构造函数。
- 对象生成时构造函数自动被调用。对象一旦生成，就再也不能在其上执行构造函数。
- 一个类可以有多个构造函数（函数重载）。
- 对象生成调用的可能是构造函数或复制构造函数。
1.3 构造函数的意义：
构造函数执行必要的初始化工作，有了构造函数就不必再写初始化函数，也不用担心对象没有初始化。
1.4 代码实例：
#include<iostream>
#include<string>
using namespace std;
class Myclass{
private :
int int_a;
string str;
public :
Myclass(int x = 0,string y = "123"){
int_a = x;
str = y;
}
void print(){
cout << int_a << " " << str << endl;
}
};
int main()
{
Myclass mc(1,"456");
mc.print();
return 0;
}1.5 可以有多个构造函数，参数个数或类型不同（函数重载）：
1.5.1 冒号语法在构造函数中用法： 用在构造函数后表示：初始化列表
构造函数初始化时必须采用初始化列表一共有三种情况：
- 需要初始化的数据成员是成员对象
- 需要初始化const 修饰的类成员
- 需要初始化引用成员数据
#include<iostream>
#include<string>
using namespace std;
class Myclass{
private :
int int_a;
string str;
public :
Myclass(int x,string y):int_a(x),str(y) {}//1
Myclass(int x):int_a(x) {}//2
Myclass(string y):str(y) {}//3
void print(){
cout << int_a << " " << str << endl;
}
};
int main()
{
Myclass mc(1,"456");//调用1
Myclass mc2(5);//调用2
Myclass mc3("abc");//调用3
return 0;
}1.6 构造函数参数可以是类本身：
#include<iostream>
#include<string>
using namespace std;
class Complex {
private :
double real, imag;
public:
Complex(double r, double i );
Complex (double r );
Complex (Complex c1, Complex c2);
};
Complex::Complex(double r, double i) {
real = r; imag = i;
}
Complex::Complex(double r){
real = r; imag = 0;
}
Complex::Complex (Complex c1, Complex c2){
real = c1.real+c2.real;
imag = c1.imag+c2.imag;
}
int main()
{
Complex c1(3) , c2 (1,0), c3(c1,c2);// c1 = {3, 0}, c2 = {1, 0}, c3 = {4, 0};
return 0;
}1.7 构造函数在数组中的使用：
每生成一个类，就调用一次构造函数。生成数组类的时候，可以用 { } 对对应的类调用构造函数。
#include<iostream>
using namespace std;
class Test {
public:
Test( int n) { } //(1)
Test( int n, int m) { } //(2)
Test() { } //(3)
};
int main()
{
Test array1[3] = { 1, Test(1,2) };
// 三个元素分别用(1),(2),(3)初始化
Test array2[3] = { Test(2,3), Test(1,2) , 1};
// 三个元素分别用(2),(2),(1)初始化
Test * pArray[3] = { new Test(4), new Test(1,2) };
//两个元素分别用(1),(2) 初始化
return 0;
}
2.复制构造函数
2.1 基本概念：
- 只有一个参数，即对同类对象的引用
- 形如X::X( X& )或X::X( const X &),二者选一，后者能以常量对象作为参数
- 如果没有定义复制构造函数，那么编译器生成默认复制构造函数。默认的复制构造函数完成复制功能
注：
- 不允许有形如 X::X( X )的构造函数
- 如果定义了自己的复制构造函数，那默认复制构造函数将不存在
2.2 复制构造函数起作用的三种情况：
- 当用一个对象去初始化同类的另一个对象时
Complex c2(c1);
Complex c2 = c1;//初始化语句，非赋值语句。 - 如果某函数有一个参数是类A的对象，那么该函数被调用时，类A的复制构造函数将被调用
#include<iostream>
#include<string>
using namespace std;
class A
{
public:
A() { };
A( A & a) {
cout << "Copy constructor called" <<endl;
}
};
void Func(A a1){ }
int main(){
A a2;
Func(a2);
return 0;
}- 如果函数的返回值是类A的对象时，则函数返回时，A的复制构造函数被调用
#include<iostream>
#include<string>
using namespace std;
class A
{
public:
int v;
A(int n) { v = n; };
A( const A & a) {
v = a.v;
cout << "Copy constructor called" <<endl;
}
};
A Func() {
A b(4);
return b;
}
int main() {
cout << Func().v << endl;
return 0;
}输出结果：Copy constructor called
4
有些编译器会对上述代码进行优化（如dev），那么就只会输出4。
注：对象之间赋值并不导致复制构造函数被调用
2.3 常量引用参数的使用：
void Fun(Myclass obj_){
cout << "fun" <<endl;
}3.析构函数
3.1 什么是析构函数：名字与类名相同，在前面加‘~’，没有参数和返回值，一个类最多只能有一个析构函数。
3.2 特点：
- 名字与类名相同，在前面加‘~’， 没有参数和返回值，一 个类最多只能有一个析构函数。
- 析构函数对象消亡时即自动被调用。可以定义析构函数来在对象消亡前做善后工作，比如释放分配的空间等。
- 如果定义类时没写析构函数，则编译器生成缺省析构函数。 缺省析构函数什么也不做。
- 如果定义了析构函数，则编译器不生成缺省析构函数。
3.3 代码实例：
#include<iostream>
using namespace std;
class A
{
public:
~A(){
cout << "now" <<endl;
}
};
void Fun(){
A a;
}
int main() {
Fun();
return 0;
}当函数调用结束时，局部对象a被释放，析构函数被调用。每当一个对象消亡，就必定会调用析构函数。
3.4 析构函数和数组：对象数组生命期结束时，对象数组的每个元素的析构函数都会被调用。
3.5 析构函数和delete运算符：
- delete导致析构函数被调用
- 若new一个对象数组，那么用delete释放时应写[]。否则只delete一个对象（调用一次析构函数）
Ctest * pTest;
pTest = new Ctest; //构造函数调用
delete pTest; //析构函数调用
pTest = new Ctest[3]; //构造函数调用3次
delete [] pTest; //析构函数调用3次 4.类型转换构造函数
4.1 基本概念：
- 定义转换构造函数的目的是实现类型的自动转换
- 只有一个参数，而且不是复制构造函数的构造函数，一般就可以看作是类型转换构造函数
- 当需要的时候，编译系统会自动调用类型转换构造函数，建立一个无名的临时对象（或临时变量）
4.2 代码实例：
#include<iostream>
using namespace std;
class A{
public:
int first;
double second;
A(int a){
this->first = a;
this->second = 0.5;
}
};
int main()
{
A a = 4;//调用了类型转换构造函数
a = 5;//调用了类型转换构造函数
cout << a.first << " " << a.second << endl;
return 0;
}