C++构造函数和析构函数的学习

构造函数是类中特殊的成员函数。

    创建类类型的新对象的，系统会自动调用构造函数。

    构造函数的调用是为了保证每个数据成员都能被正确初始化。

    构造函数的作用初始化。

    通常情况下，构造函数应声明为公有函数，构造它不能像其他成员函数那样被显式的调用。

    构造函数被声明为私有有特殊的用途。

    构造函数可以有任意类型和任意个数的参数，一个类可以有多个构造函数。

    如果程序未声明构造函数，默认会生成一个空的构造函数。

    不带参数的构造函数称为默认构造函数。

    如果有一个构造函数，系统不再生成默认构造函数

 

Test.h

//Test.h
# ifndef _TEST_H_
# define _TEST_H_

class Test
{
public: //如果程序未声明构造函数，默认会生成一个空的构造函数
    Test();
private:
    int num_;
};

# endif //_TEST_H_

Test.cpp

//Test.cpp
# include "Test.h"
# include
using namespace std;

Test::Test()
{
    num_ = 0;
    cout << "Initializing Default " << endl;
}

main.cpp

 

# include
# include "Test.h"
using namespace std;

int main(void)
{ //自动调用构造函数
    Test t;

    return 0;
}

 运行结果：

 //    如果有一个构造函数，系统不再生成默认构造函数

 

Test.h

//Test.h
# ifndef _TEST_H_
# define _TEST_H_

class Test
{
public: //如果程序未声明构造函数，默认会生成一个空的构造函数
    Test(int num);
private:
    int num_;
};

# endif //_TEST_H_

Test.cpp

//Test.cpp
# include "Test.h"
# include
using namespace std;

Test::Test(int num)
{
    num_ = num;
    cout << "Initializing " << num_  << endl;
}

main.cpp

 

# include
# include "Test.h"
using namespace std;

int main(void)
{ //自动调用构造函数
    Test t(10);

    return 0;
}

 运行结果:

 

 

构造函数重载的实例：

 

Test.h

//Test.h
# ifndef _TEST_H_
# define _TEST_H_

class Test
{
public: //如果程序未声明构造函数，默认会生成一个空的构造函数
Test();
    Test(int num);
private:
    int num_;
};

# endif //_TEST_H_

Test.cpp

//Test.cpp
# include "Test.h"
# include
using namespace std;

Test::Test()
{
num_ = 0;
    cout << "Initializing default "  << endl;
}

Test::Test(int num)
{
    num_ = num;
    cout << "Initializing " << num_  << endl;
}

main.cpp

# include
# include "Test.h"
using namespace std;

int main(void)
{ //自动调用构造函数
    Test t1;
Test t2(10);

    return 0;
}

 运行结果:

 

 构造函数与new运算符

//构造函数与new运算符

# ifndef _TEST_H_
# define _TEST_H_

class Test
{
public:
    ////可以显式的写一个默认构造函数，这样两个函数就成了重载
    Test();
    Test(int num);
    //析构函数不能重载
    //析构函数不能带参数，如果带参数就可以重载
    ~Test();
    void Display();
private:
    int num_;
};

# endif

Test.cpp

# include "Test.h"
# include
using namespace std;

void Test::Display()
{
    cout << num_ << endl;
}
Test::Test()
{
    num_ = 0;
    cout<<"Initializing Default" << endl;

}
Test::Test(int num)
{
    num_ = num;
    cout<<"Initializing "<
}

Test::~Test()
{
    cout << "Destory " << num_ << endl;
}

main.cpp

# include
# include "Test.h"
using namespace std;

int main(void)
{
    Test t;
    t.Display();

    Test t2(20);
    t2.Display();
//不仅仅分配了内存，还调用了构造函数
    Test * t3 = new Test(20);  //new operator
    t3->Display();
//不仅仅释放了内存，也调用了析构函数
    delete t3;

    return 0;
}

 

运行结果：

 

//全局对象的构造先于main函数 

 

# ifndef _TEST_H_
# define _TEST_H_

class Test
{
public:
    ////可以显式的写一个默认构造函数，这样两个函数就成了重载
    Test();
    Test(int num);
    //析构函数不能重载
    //析构函数不能带参数，如果带参数就可以重载
    ~Test();
    void Display();
private:
    int num_;
};

# endif

Test.cpp

# include "Test.h"
# include
using namespace std;

void Test::Display()
{
    cout << num_ << endl;
}
Test::Test()
{
    num_ = 0;
    cout<<"Initializing Default" << endl;

}
Test::Test(int num)
{
    num_ = num;
    cout<<"Initializing "<
}

Test::~Test()
{
    cout << "Destory " << num_ << endl;
}

 

main.cpp

# include "Test.h"
using namespace std;

//全局对象的构造先于main函数
Test t(10);

int main(void)
{
    cout << "Entering main ..." << endl;
    cout << "Exiting  main ..." << endl;

    return 0;
}

运行结果：

 

 

    默认析构函数是一个空函数

    析构函数没有参数

    析构函数不能被重载

 

    析构函数与数组

Test.h

//Test.h
# ifndef _TEST_H_
# define _TEST_H_

class Test
{
public:
    ////可以显式的写一个默认构造函数，这样两个函数就成了重载
    Test();
    Test(int num);
    //析构函数不能重载
    //析构函数不能带参数，如果带参数就可以重载
    ~Test();
    void Display();
private:
    int num_;
};

# endif //_TEST_H_

Test.cpp

//Test.cpp
# include
# include "Test.h"
using namespace std;

void Test::Display()
{
    cout << num_ << endl;
}
Test::Test()
{
    num_ = 0;
    cout<<"Initializing Deafule " << endl;
}
Test::Test(int num)
{
    num_ = num;
    cout<<"Initializing "<
}

Test::~Test()
{
    cout << "Destory " << num_ << endl;
}

 

main.cpp

//main.cpp
# include
# include "Test.h"
using namespace std;

int main(void)
{      //定义对象数组
    Test t[2] = {10,20};
    //动态对象
    Test* t2 = new Test(2); //传递参数2
    delete t2;
    //没有传递任何参数，创建了两个对象
    Test* t3 = new Test[2];
    delete[] t3;

    return 0;
}

运行结果：

    析构函数不能重载

 

    析构函数不能带参数，如果带参数就可以重载

 

    析构函数可以显式调用，一般很少用到，会实现一些特殊的效果：

//main.cpp
# include "Test.h"

int main(void)
{
    Test t;
    t.~Test(); //析构函数被调用了两次
    //析构函数很少调用，可以显式调用
    return 0;
}