目录

 

构造函数：

构造函数需要注意的几点：

单参构造与类型转换：

初始化列表：

析构函数：

构造函数：

构造函数是类的一种特殊的成员函数，特点是：会在创造一个新对象时调用执行。

构造函数需要注意的几点：

1、构造函数是可以被重载的，不会有冲突，并且同一个名字的函数可以有多个版本。

Stu(void)
{
    cout << "我是无参构造" << endl;
}
Stu(const char* name,char sex)
{
    cout << "我是有参构造，我的参数是name，sex" << endl;
}
Stu(int id,short age)
{
    cout << "我是有参构造，我的参数是id,age" << endl;
}

2、缺省构造是编译器自动生成的一个什么都不做的构造函数（唯一的作用就是避免系统错误）。

注意：当类实现一个有参构造后，无参构造就不会再自动生成，如果有需要必须显式的写出来。

3、无参构造未必是真的无参，当给有参构造的所有参数设置默认形参，调用这种构造函数就不需要传参。

单参构造与类型转换：

class Test
{
public:
    int num;
    
    Test(int n)
    {
        num = n;
    }
};

int main()
{
    Test t = 20; //这部操作其实只是实现了单参构造，缺会给人一个类型转换的错觉
}

注意：

如果构造函数的参数只有一个，那么Test t = n 这个语句就不会出错，它会自动调用单参构造来达到类型转换的效果。

如果想禁止这种类型转换，则需要在单参构造前加 explicit

初始化列表：

初始化列表是给类做初始化用的。

初始化方法1：

class Test
{
public:
    const int num;
};

int main()
{
    Test t = {10};
    cout << t.num << endl;
}

初始化方法2:

class Test
{
public:
    const int num;
    Test(int n):num(n)
    {}
};

int main()
{
    Test t(10);
    cout << t.num << endl;
}

初始化方法3：

class Test
{
public:
    string str;
    const int num;
    Test(int num,const char* str):num(num),str(str)
    {
        
    }
};

int main()
{
    Test t(10,"1234");
}

析构函数：

析构函数也是类的一种特殊成员函数。

析构函数会在销毁对象时自动调用，在对象的整个生命周期内最多被调用一次。

析构函数负责释放在构造函数期间获取的所有资源

它的执行过程：

1、先执行函数本身析构

2、调用成员类的析构

3、调用父类的析构

缺省的析构函数：

如果一个类中没有实现析构函数，编译器会自动生成一个具有析构函数功能的二进制指令，这就是缺省析构，它负责释放编译器能够看得到的资源（成员变量、类成员、父类成员）。

如果一个类没有动态资源，也不需要做善后工作，缺省析构就完全够用了，不需要再实现新的析构函数
注意：缺省析构无法释放动态资源（例如堆内存中的）。

构造函数

成员函数的一种
名字与类名相同，可以有参数，不能有返回值(void也不行)
作用是对对象进行初始化，如给成员变量赋初值
对象生成时构造函数自动被调用。对象一旦生成，就再也不能在其上执行构造函数
一个类可以有多个构造函数

构造函数调用方式：

显式调用：CLASS a=CLASS(参数列表)；
隐式调用：CLASS a(参数列表)；

为什么需要构造函数：

构造函数执行必要的初始化工作，有了构造函数，就不

必专门再写初始化函数，也不用担心忘记调用初始化函数。
有时对象没被初始化就使用，会导致程序出错。

几种特殊构造函数：
默认构造函数：

即无参数（或者缺省类型参数）的构造函数
如果定义类时没写构造函数，则编译器生成一个默认的无参数 的构造函数
默认构造函数无参数，不做任何操作
如果定义了构造函数，则编译器不生成默认的无参数的构造函数

类型转换构造函数：

通常来说只有一个参数且不是复制构造函数的构造函数即可认为是类型转换函数。

也就是说只有一个参数的构造函数允许使用赋值语法来初始化对象和进行赋值操作。
需要注意的是，使用类型转换构造函数初始化时不会生成临时对象，而进行赋值操作时编译系统会自动调用转换构造函数，建立 一个无名的临时对象(或临时变量)。
但有时候设计者可能希望单参数构造函数有其他作用，此时为了防止语义混淆不清，可以使用explicit关键字防止类构造函数的隐式自动转换

.例子如下：
class Complex {
public:
double real, imag;
explicit Complex( int i) {//显式类型转换构造函数
cout << "IntConstructor called" << endl;
real = i; imag = 0;
}
Complex(double r,double i) {real = r; imag = i; }
};
int main () {
Complex c1(7,8);
Complex c2 = Complex(12);
c1 = 9; // error, 9不能被自动转换成一个临时Complex对象
c1 = Complex(9) //ok
cout << c1.real << "," << c1.imag << endl;
return 0;
}


类型转换构造函数将double ，int等其他类型值转换为对象。那么对应就有转换函数可以将对象转换为其他数据类型。

格式如下：在class内：operator typename()。同样的也可以用关键字explicit来关闭其隐式转换（c++11）

复制（拷贝）构造函数：

即只有一个参数且为对象的引用的构造函数（A：：A（A & ）或A::A(const A&),A为某构造类)。
如果没有定义复制构造函数，那么编译器生成默认 复制构造函数。默认的复制构造函数完成复制功能。
如果定义的自己的复制构造函数， 则默认的复制构造函数不存在。

复制构造函数起作用的三种情况

当用一个对象去初始化同类的另一个对象时。


    Complex c2(c1);
    Complex c2 = c1; //初始化语句，非赋值语句


如果某函数有一个参数是类 A 的对象，那么该函数被调用时，类A的复制构造函数将被调用。


	void Func(A a1){ }
	int main(){
	A a2;
	Func(a2);
	return 0;
	}
	程序输出结果为: Copy constructor called


如果函数的返回值是类A的对象时，则函数返回时，A的复制构造函数被调用:

	A Func() {
	A b(4);
	return b;
	}
	int main() {
	cout << Func().v << endl;
	return 0;
	}
	输出结果：
	Copy constructor called

※注意：对象间赋值并不导致复制构造函数被调用
默认复制构造函数可能出现的问题：

复制构造函数是按值进行复制的，当遇到类成员里有指针变量时，它无法复制指针指向的内容而仅仅是复制了地址，使得两指针指向同一片内存。
默认构造函数在其创建的临时对象消亡时会调用析构函数，当析构函数是设计者创建含静态变量的类时，如在顺序栈类中，析构函数显然需要将top–，如若不小心调用默认的复制构造函数创建了对象，那么对象消亡时调用析构函数会使top–即多减了1.

常量引用参数的使用
void fun(CMyclass obj_ ) {
	cout << "fun" << endl;
} 

这样的函数，调用时生成形参会引发复制构造函数调用，开销比较大。

所以可以考虑使用 CMyclass & 引用类型作为参数。

如果希望确保实参的值在函数中不应被改变，那么可以加上const 关键字：
void fun(const CMyclass & obj) {
//函数中任何试图改变 obj值的语句都将是变成非法
}

析构函数：


名字与类名相同，在前面加‘ ~’ ， 没有参数和返回值，


一个类最多只能有一个析构函数。


析构函数对象消亡时即自动被调用。
比如

delete对象

参数对象消亡

临时对象消亡


可以定义析构函数来在对象消亡前做善后工作，比如释放分配的空间等。


如果定义类时没写析构函数，则编译器生成缺省析构函数。 缺省析构函数什么也不做。


如果定义了析构函数，则编译器不生成缺省析构函数。


关于构造函数和析构函数什么时候被调用：


C++自动提供的成员函数：

默认构造函数
默认析构函数
复制构造函数
赋值运算符
地址运算符

有时候这些默认的定义会与设计的类需要的功能不符，所以需要自己设计默认构造函数，析构函数，复制构造函数以及重载相关的运算符。
（本文参考北大郭炜老师的慕课程序设计与算法三和《C++primer plus 第六版》，如有错误还望大佬指出）

构造函数

每个类都分别定义了它的对象被初始化的方式，类通过一个或几个特殊成员函数来控制其对象的初始化过程，这些函数叫做构造函数。构造函数的任务是初始化类对象的数据成员，无论何时只要类的对象被创建，就会执行构造函数。

构造函数是特殊的成员函数，用来保证每个对象的数据成员具有合适的初始值。

构造函数名字与类名相同，不能指定返回类型（也不能定义返回类型为void），可以有0-n个形参。

在创建类的对象时，编译器就运行一个构造函数。

默认构造函数

当我们没有显式的在声明中添加构造方法时，编译器会默认提供一个空参列表且没有任何行为的默认构造方法，会帮助我们初始化对象，就像下面这样


Student() {}


但是当我们声明了自己的构造方法之后，编译器便不会再提供默认的构造方法了，我们需要自己创建一个默认构造函数，使得对象可以无参数初始化。

当我们想定义一个默认的构造器有两种方式：

1，给已有的构造函数的所有参数提供默认值


Student(std::string name,int chScore=0,int enScore=0,int mathScore=0)；


2，定义一个没有参数的函数重载


Student()；


注意：声明隐式方式调用空参构造方法不能使用括号，因为这是编译器会将这行代码解释为函数声明，比如：

Student jack;//available
Student jack();//invalidate

 

创建自己的构造函数

构造函数与普通函数在声明与定义上别无二致，除了不需要声明返回值。在声明中添加如下代码


Student::Student(std::string name, int ch=0, int en=0, int math=0);


在实现中的一般实现方式为


Student::Student(string name, int ch,int en,int math){

    setName(name);

    setChScore(ch);

    setMathScore(math);

    setEnScore(en);

    show();

}


 

引用参数与构造函数

如果成员是 const、引用，或者属于某种未提供默认构造函数的类类型，我们必须通过构造函数初始值列表为这些成员提供初值。


std::string & name;


比如我们的 name 属性是引用类型，那么我们需要在每一个构造方法实现的参数列表后面加上这样的初始化器


Student::Student(std::string &n):name(n){

......

}

Student::Student(std::string &n,int chScore,int enScore,int mathScore):name(n){

......

}


如果我们有多个引用需要初始化，这些构造器只需要使用，逗号分割,并且除了引用类型，任何类型属性都可以使用这种方式初始化


Class::Constructor(type *t1, type &t2, type t3...):t1(t1),t2(t2),t3(t3)...{}


我们把冒号后出现的部分称为构造函数初始化列表，它负责为新创建的对象的一个或几个数据成员赋初值。构造函数初始值是成员名字的一个列表，每个名字后面紧跟括号括起来的（或者在或括号内的）成员初始值。不同成员的初始化通过逗号分隔开来。

 

使用构造函数定义对象

当我们声明过一个构造函数之后，我们可以有三种方式去调用它：

1，显式的调用


Student Jack = Student("Jack",99,98,97);


2，隐式的调用


Student Jack("Jack",99,98,97);


3，使用 new 运算符


Student *Jack = new Student("Jack",99,98,97);


上述 3 种方法的关键区别在于内存分配：前两种方式的对象将会被在栈中创建，第3种方式对象将会在堆中被创建。

 

委托构造函数

C++11 新标准扩展了委托构造函数初始值的功能，使得我们可以定义所谓的委托构造函数。一个委托构造函数使用它所属类的其他构造函数执行它自己的初始化过程，或者说它把它自己的一些（或全部）职责委托给了其他构造函数。


Student():Student("Tony",80,80,80){};


 

析构函数

析构函数是当对象被销毁时被系统调用的方法，一般用来清空内存。

析构函数的声明只用一种形式，就是~加上类名


~Student();


析构函数的实现就可以根据需求去自定义


Student::~Student(){

    cout << "Destroy a object: " << name << endl;

}


 

析构函数的执行时机


析构函数的执行与对象的创建位置相关

1，当对象被声明为全局变量，则当整个程序退出时，其析构函数才会被调用。

2，当对象被声明为自动存储类型(局部变量)，当其生命周期结束，即其作用域执行完毕时，其析构函数会被调用。

3，当对象被声明为指针变量(使用new创建对象)，当执行到delete方法时，其析构函数会被调用。

4，临时对象，这种对象在临时对象完成任务时自动调用其析构函数。如 (Student Sue = Student("Sue",88,51,72);)


const成员函数

有如下代码：


const Student Jack("Jack",99,98,97);

Jack.show();//complier error


因为我们已经将jack对象声明为const类型，所以当我们在调用show()方法时，编译器并不知道其中有没有更改对象内容的方法。所以拒绝编译。如果我们非要这么做的话，可以采用以下方式对show()函数重新定义


void show() const;


 

 

 

示例：

头文件 student.h

//Student.h -- Student class interface
//version 00
#ifndef Student_H_
#define Student_H_


#include <string>

class Student{ //class declaration
private:
	std::string name;
	int ch;
	int en;
	int math;
	float average;
	void count(){
		average = (ch + en + math + 0.0F) / 3;
	}

public:
	Student();//构造函数
	Student::Student(std::string name, int ch=0, int en=0, int math=0);
	~Student();//析构函数
	void setName(std::string name);
	void setChScore(int score);
	void setEnScore(int score);
	void setMathScore(int score);
	void show();
};

#endif

student.c

//Student.cpp -- implementing the Student class
//version 00

#include "stdafx.h"
#include "Student.h"
#include <iostream>
using namespace std;

Student::Student(){
	cout << "Create a new Student object.\n";
}

Student::Student(string name, int ch,int en,int math){
	setName(name);
	setChScore(ch);
	setMathScore(math);
	setEnScore(en);
	show();
}

Student::~Student(){
	cout << "Destroy a object: " << name << endl;
}

void Student::setChScore(int score){
	Student::ch = score;	// 在类内部使用 可省略 Student，无需显示作用域 
}

void Student::setName(std::string n){
	Student::name = n;
}

void Student::setEnScore(int score){
	en = score;
}

void Student::setMathScore(int score){
	math = score;
}

void Student::show(){
	Student::count();
	//ios_base::fmtflags orig = cout.setf(ios_base::fixed, ios_base::floatfield);
	//std::streamsize prec = cout.precision(1);
	cout << name << " 同学的语文成绩为" << ch << "分，数学成绩为" << math << "分，英语成绩为" 
		<< en << "分，平均成绩" << average << "分" << endl;
	//cout.setf(orig, ios_base::floatfield);
}

class.c // 主函数

// class.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include "Student.h"
#include <iostream>
#include "stdlib.h"
using namespace std;

void test(){

	Student *Jack = new Student();
	Jack->setName("Jack");
	Jack->setChScore(98);
	Jack->setMathScore(100);
	Jack->setEnScore(92);
	Jack->show();
	Student *Lucci = new Student("Lucci",85);
	delete Jack;
	delete Lucci;

	Student Sue;
	Sue = Student("Sue", 85, 90, 95);	// 创建了一个临时对象，且复制给了对象 Sue

	Student jack("Tom", 81, 50, 56);
	Student Herry("Herry", 75, 59, 95);


}


int _tmain(int argc, _TCHAR* argv[]){

	test();
	system("pause");
	return 0;
}



运行结果：



 

结果分析：

我们可以看到输出的第一、二行，表示在堆中开辟一块内存创建了对象 Jack，运行了默认构造函数。

第三行的输出也是在堆中中创建了对象 Lucci，运行了我们自己写的构造函数，语文成绩为我们的实参所改，为85，其他为默认参数。

由于对象 Jack 和 Lucci 都是在堆中开辟内存空间，因此需要我们主动释放内存空间，即 delete。从而进行了对象的析构，对应输出如四五行。

后面默认初始化了对象 Sue，如第六行，随后创建了一个临时对象且拷贝给对象 Sue。这时有了第七行的自制的构造函数输出，拷贝完毕后临时对象解析，有了第八行。九十行用了隐式调用构造函数在栈中创建了对象 Tom 和 Herry。

后续的解析函数的输出顺序遵从栈的先进后出原则。

 

 

 

 

参考：

https://blog.csdn.net/bcbobo21cn/article/details/71155764

https://blog.csdn.net/qq_32583189/article/details/52415478

析构函数
类可以用用析构函数（destructor）,它可以在一个类的实例不在被引用的时候执行一些操作，以清除或释放非托管资源。非托管资源是指类似用Win32 API或非托管内存块获取的文件句柄这样的资源。使用.NET资源是无法获取它们的，因此如果我们只用.NET类。是不需要编写太多的析构函数的。
        关于析构函数要注意以下几点。
·每个类只能有一个析构函数。
·析构函数不能有参数。

·析构函数不能有访问修饰符。
·析构函数名称与类名相同，但是前面加一个波浪符。
·析构函数只能作用于类的实例。因此没有静态的析构函数。
·不能再代码中显示调用析构函数。相反，当垃圾回收器分析代码并认为代码中不存在指向对象的可能路径时，系统会在垃圾回收中调用析构函数。
使用析构函数是一些重要的原则如下：
·不要在不需要时实现析构函数。这会严重影响性能；
·析构函数应该只释放对象拥有的外部资源。
·析构函数不应该访问其他对象，因为无法认定这些对象是否已经被销毁。
标准dispose模式
标准dispose模式包含以下特点。
·包含非托管资源的类应该事先IDisposable接口，后者包含单一方法Dispose。Dispose包含释放资源的清除代码。
·如果代码使用完了这些资源且希望将他们释放，应该在程序代码中调用Dispose方法。注意，这是在你的代码中调用Dispose。
·你都累还应该实现一个析构函数，在其中调用Dispose方法，以防止之前没有调用该方法。你想讲所有的清除代码放到Dispose中，并在使用完资源时调用。以防止Dispose没有调用，类的析构函数也应该调用Dispose。而另一方面如果调用了Dispose，你就希望通知垃圾回收器不要在调用析构函数，因为已经由Dispose执行了清除操作。
析构函数和Dispose代码应该遵循以下原则。
·修改函数和Dispose方法的逻辑应该是，如果由于某种原因代码没有调用Dispose，那么修改函数应该调用它，并释放资源。
·在Dispose方法的最后应该调用GC.SuppressFinalize方法，通知CLR不要电泳该对象的析构函数，因为清除工作已经完成。
·在Dispose中实现这些代码。这样多次调用该方法是安全的。也就是说代码要这样写：如果该方法已经被调用，那么任何后续调用都不回执行额外的工作，也不会抛出任何异常。


标准Dispose模式，要点：
·Dispose方法有两个重载：一个是public的，一个protected的。protected的重载包含实际的清除代码。
·public 版本可以在代码中显示调用以执行清除工作。它会调用protected版本。

·析构函数调用protected版本、
`protected版本的bool参数通知方法是被析构函数或是其他代码调用。这一点很重要，因为结果不同所执行的操作略有不同。
案例

 class Class1 : IDisposable

    {


        bool disposed = false;

        public void Dispose()

        {

            Dispose(true);

            GC.SuppressFinalize(this);

        }


        ~Class1()

        {

            Console.WriteLine("析构函数释放了");

            Dispose(false);

        }


        protected virtual void Dispose(bool disposing)

        {


            if (disposed == false)

            {

                if (disposed == true)

                {

                    //由Dispose是释放

                }

                else if (disposed == false)

                {

                    //由析构函数释放

                }

                disposed = true;

            }

        }


        static void Main(string[] args) {

            Class1 c = new Class1();

            Console.ReadKey();

        }

    }