c++——对象的构造和析构函数、构造函数的分类及调用

1构造函数和析构函数的概念

有关构造函数

1构造函数定义及调用

1）C++中的类可以定义与类名相同的特殊成员函数，这种与类名相同的成员函数叫做构造函数；

2）构造函数在定义时可以有参数；

3）没有任何返回类型的声明。

2构造函数的调用

自动调用：一般情况下C++编译器会自动调用构造函数

手动调用：在一些情况下则需要手工调用构造函数

有关析构函数

3）析构函数定义及调用

1）C++中的类可以定义一个特殊的成员函数清理对象，这个特殊的成员函数叫做析构函数

语法：~ClassName()

2）析构函数没有参数也没有任何返回类型的声明

3）析构函数在对象销毁时自动被调用

4）析构函数调用机制

C++编译器自动调用

构造函数的分类及调用

C++编译器给程序员提供的对象初始化方案，高端大气上档次。

//有参数构造函数的三种调用方法

class Test

{

private:

int a;

int b;

public:

//无参数构造函数

Test()

{

;

}

//带参数的构造函数

Test(int a, int b)

{

;

}

//赋值构造函数

Test(const Test &obj)

{

;

}

public:

void init(int _a, int _b)

{

a = _a;

b = _b;

}

};

1无参数构造函数

调用方法： Test t1, t2;

2有参构造函数

有参构造函数的三种调用方法

//有参数构造函数的三种调用方法

class Test5

{

private:

int a;

public:

//带参数的构造函数

Test5(int a)

{

printf("\na:%d", a);

}

Test5(int a, int b)

{

printf("\na:%d b:%d", a, b);

}

public:

};

int main55()

{

Test5 t1(10);  //c++编译器默认调用有参构造函数 括号法

Test5 t2 = (20, 10); //c++编译器默认调用有参构造函数 等号法

Test5 t3 = Test5(30); //程序员手工调用构造函数 产生了一个对象 直接调用构造构造函数法

system("pause");

return 0;

}

3拷贝构造函数调用时机（用一个对象初始化另一个对象时）

赋值构造函数的四种调用场景（调用时机）

第1和第2个调用场景

#include "iostream"

using namespace std;

class AA

{

public:

AA() //无参构造函数 默认构造函数

{

cout<<"我是构造函数，自动被调用了"<<endl;

}

AA(int _a) //无参构造函数 默认构造函数

{

a = _a;

}

AA(const AA &obj2)

{

cout<<"我也是构造函数，我是通过另外一个对象obj2，来初始化我自己"<<endl;

a = obj2.a + 10;

}

~AA()

{

cout<<"我是析构函数，自动被调用了"<<endl;

}

void getA()

{

printf("a:%d \n", a);

}

protected:

private:

int a;

};

//单独搭建一个舞台

void ObjPlay01()

{

AA a1; //变量定义

//赋值构造函数的第一个应用场景

//用对象1 初始化 对象2

AA a2 = a1; //定义变量并初始化 //初始化法

a2 = a1; //用a1来=号给a2 编译器给我们提供的浅copy

}

第二个应用场景

//单独搭建一个舞台

void ObjPlay02()

{

AA a1(10); //变量定义

//赋值构造函数的第一个应用场景

//用对象1 初始化 对象2

AA a2(a1); //定义变量并初始化 //括号法

//a2 = a1; //用a1来=号给a2 编译器给我们提供的浅copy

a2.getA();

}

//注意：初始化操作 和 等号操作 是两个不同的概念

第3个调用场景

#include "iostream"

using namespace std;

class Location

{

public:

Location( int xx = 0 , int yy = 0 )

{

X = xx ;  Y = yy ;  cout << "Constructor Object.\n" ;

}

Location( const Location & p )            //复制构造函数

{

X = p.X ;  Y = p.Y ;   cout << "Copy_constructor called." << endl ;

}

~Location()

{

cout << X << "," << Y << " Object destroyed." << endl ;

}

int  GetX () { return X ; }          int GetY () { return Y ; }

private :   int  X , Y ;

} ;

//alt + f8 排版

void f ( Location  p )

{

cout << "Funtion:" << p.GetX() << "," << p.GetY() << endl ;

}

void mainobjplay()

{

Location A ( 1, 2 ) ;  //形参是一个元素，函数调用，会执行实参变量初始化形参变量

f ( A ) ;

}

void main()

{

mainobjplay();

system("pause");

}

第4个调用场景

第四个应用场景

#include "iostream"

using namespace std;

class Location

{

public:

Location( int xx = 0 , int yy = 0 )

{

X = xx ;  Y = yy ;  cout << "Constructor Object.\n" ;

}

Location( const Location & p )            //复制构造函数

{

X = p.X ;  Y = p.Y ;   cout << "Copy_constructor called." << endl ;

}

~Location()

{

cout << X << "," << Y << " Object destroyed." << endl ;

}

int  GetX () { return X ; }          int GetY () { return Y ; }

private :   int  X , Y ;

} ;

//alt + f8 排版

void f ( Location  p )

{

cout << "Funtion:" << p.GetX() << "," << p.GetY() << endl ;

}

Location g()

{

Location A(1, 2);

return A;

}

//对象初始化操作 和 =等号操作 是两个不同的概念

//匿名对象的去和留，关键看，返回时如何接

void mainobjplay()

{

//若返回的匿名对象，赋值给另外一个同类型的对象，那么匿名对象会被析构

//Location B;

//B = g();  //用匿名对象 赋值 给B对象，然后匿名对象析构

//若返回的匿名对象，来初始化另外一个同类型的对象，那么匿名对象会直接转成新的对象

Location B = g();

cout<<"传智扫地僧测试"<<endl;

}

void main()

{

mainobjplay();

system("pause");

}

4默认构造函数

二个特殊的构造函数

1）默认无参构造函数

当类中没有定义构造函数时，编译器默认提供一个无参构造函数，并且其函数体为空

2）默认拷贝构造函数

当类中没有定义拷贝构造函数时，编译器默认提供一个默认拷贝构造函数，简单的进行成员变量的值复制

3.3构造函数调用规则研究

1）当类中没有定义任何一个构造函数时，c++编译器会提供默认无参构造函数和默认拷贝构造函数

2）当类中定义了拷贝构造函数时，c++编译器不会提供无参数构造函数

3） 当类中定义了任意的非拷贝构造函数（即：当类中提供了有参构造函数或无参构造函数），c++编译器不会提供默认无参构造函数

4 ）默认拷贝构造函数成员变量简单赋值

总结：只要你写了构造函数，那么你必须用。

构造析构阶段性总结

1）构造函数是C++中用于初始化对象状态的特殊函数

2）构造函数在对象创建时自动被调用

3）构造函数和普通成员函数都遵循重载规则

4）拷贝构造函数是对象正确初始化的重要保证

5）必要的时候，必须手工编写拷贝构造函数

========》1个对象的初始化讲完了，增加一个案例。