C#的构造函数与析构函数

1.构造函数

类的构造函数是类的一个特殊的成员函数，当创建类的新对象时就会执行构造函数。默认的构造函数是没有任何参数，可以为构造函数设置参数，且构造函数的名称必须跟类名一样。

创建对象使用的关键字【new】实现过程：
1、在内存中开辟一块储存空间。
2、在这块空间上创建对象。
3、调用对象的析构函数进行对象的初始化。

1.默认使用析构函数。

class Program
{
    static void Main(string[] args)
    {
        Student stu1 = new Student();
        stu1.Name = "小明";
        stu1.StuId = "21002121";
        stu1.ShowStudentInfo();
        Console.ReadKey();
    }
}

public class Student
{
    // 默认析构函数，默认
    // public Student()
    // {
    // }
    
	public Student(string name)
    {
        Name = name;
    }

    private string _name;
    public string Name
    {
        get
        {
            return _name;
        }
        set
        {
            _name = value;
        }
    }

    private string _stuId;
    public string StuId
    {
        get
        {
            return _stuId;
        }
        set
        {
            _stuId = value;
        }
    }

    public void ShowStudentInfo()
    {
        Console.WriteLine("姓名：{0} 学号：{1}", Name, StuId);//输出：姓名：小明 学号：21002121
    }
}

2.定义多个不同形参的析构函数

class Program
{
    static void Main(string[] args)
    {
        Student stu1 = new Student();
        //调用stu1对象的Student()析构方法
        stu1.ShowStudentInfo();
        //输出：姓名：大一 学号：00000001

        Student stu2 = new Student("大二");
        //调用stu2对象的Student(string name)析构方法
        stu2.ShowStudentInfo();
        //输出：姓名：大二 学号：00000002

        Student stu3 = new Student("大三", "00000003");
        //调用stu3对象的Student(string name, string stuId)析构方法
        stu3.ShowStudentInfo();
        //输出：姓名：大三 学号：00000003

        Console.ReadKey();
    }
}

public class Student
{
    //自定义析构函数。
    public Student()
    {
        Name = "大一";
        StuId = "00000001";
    }

    //一个参数析构方法
    public Student(string name):this(name, "00000002")
    {
        //为了防止代码的冗余，这里采用this的方法
        //作用：调用构造函数 Student(string name, string stuId)
    }

    //两个参数析构方法
    public Student(string name, string stuId)
    {
        Name = name;
        StuId = stuId;
    }

    private string _name;
    public string Name
    {
        get
        {
            return _name;
        }
        set
        {
            _name = value;
        }
    }

    private string _stuId;
    public string StuId
    {
        get
        {
            return _stuId;
        }
        set
        {
            _stuId = value;
        }
    }

    public void ShowStudentInfo()
    {
        Console.WriteLine("姓名：{0} 学号：{1}", Name, StuId);//输出：姓名：小明 学号：21002121
    }
}

为了防止构造函数出现冗余现象，上述代码采用了【this】关键字解决。

【this】的两个作用：
1、代表当前类的对象，比如：this.Name = "张三";
2、在类中根据参数的不同，调用本类的构造函数。如上述代码所示。

2.析构函数

作用是释放资源 。但是在处理过程中GC机制会进行回收，因此析构函数最大的作用是提前释放资源。析构函数不能有参数，不能有任何修饰符而且不能被调用。析构函数与构造函数的标识符不同，特点是在析构函数前面需要加上前缀“~”以示区别。

class Program
{
    public Program()
    {
        Console.WriteLine("这是无参数构造函数");
    }
    ~Program()
    {
        Console.WriteLine("这是析构函数");
    }
    static void Main(string[] args)
    {
        Program pro1 = new Program();
    }
}

运行结果如下：
这是无参数构造函数
这是析构函数
请按任意键继续. . .

如果系统中没有指定析构函数，那么编译器由GC（Garbage Collection，垃圾回收机制）来决定什么时候进行释放资源。

3.构造函数和析构函数的例子

为了更好理解构造函数和析构函数的执行顺序，作者编写了以下程序。

class Program
{
    private string name;
    public Program()
    {
        Console.WriteLine("这是无参数构造函数");
    }
    public Program(string str)
    {
        name = str;
        Console.WriteLine("这是有参数构造函数");
    }
    ~Program()
    {
        Console.WriteLine("这是" + name + "的析构函数");
    }
    public void SetName(string str)
    {
        name = str;
    }
    public string GetName()
    {
        return name;
    }
    static void Main(string[] args)
    {
        Program pro1 = new Program();
        pro1.SetName("小明");
        Console.WriteLine(pro1.GetName());
        Program pro2 = new Program("小红");
        Console.WriteLine(pro2.GetName());
    }
}

运行结果如下：
这是无参数构造函数
小明
这是有参数构造函数
小红
这是小红的析构函数
这是小明的析构函数
请按任意键继续. . .

当调用完毕，系统就会自动执行析构函数，删除创建好的对象。

引用类型分两步创建，首先在栈上创建一个引用变量，然后在堆上创建对象本生，再把这个内存（也是内存的首地址）赋值给引用变量。如下图所示。所以当删除创建的对象时，实际是按照先进后出的原则进行的（先创建后删除）。所以这就是为什么会先输出“这是小红的析构函数”，再输出“这是小明的析构函数”。

因为作者精力有限，文章中难免出现一些错漏，敬请广大专家和网友批评、指正。

类的构造函数

• 类的构造函数是类的一种特殊的成员函数，它会在每次创建性的对象时执行
• 构造函数的名称与类的名称是完全相同的，并且不返回任何类型，也不返回void。构造函数可用于为某些成员变量设置初始值。

下面的实例有助于更好地理解构造函数的概念：

#include <iostream>
using namespace std;
 
class Line
{
   public:
      void setLength( double len );
      double getLength( void );
      Line();  // 这是构造函数
 
   private:
      double length;
};
 
// 成员函数定义，包括构造函数
Line::Line(void)
{
    cout << "Object is being created" << endl;
}
 
void Line::setLength( double len )
{
    length = len;
}
 
double Line::getLength( void )
{
    return length;
}
// 程序的主函数
int main( )
{
   Line line;//创建对象时会执行构造函数
 
   // 设置长度
   line.setLength(6.0); 
   cout << "Length of line : " << line.getLength() <<endl;
 
   return 0;
}

>>Object is being created
Length of line : 6

带参数的构造函数

默认的构造函数没有任何参数，但如果需要，构造函数也可以带有参数。这样在创建对象时就会给对象赋初始值，如下面的例子所示：

#include <iostream>
using namespace std;
 
class Line
{
   public:
      void setLength( double len );
      double getLength( void );
      Line(double len);  // 这是构造函数
 
   private:
      double length;
};
 
// 成员函数定义，包括构造函数
Line::Line( double len)
{
    cout << "Object is being created, length = " << len << endl;
    length = len;
}
 
void Line::setLength( double len )
{
    length = len;
}
 
double Line::getLength( void )
{
    return length;
}
// 程序的主函数
int main( )
{
   Line line(10.0);
 
   // 获取默认设置的长度
   cout << "Length of line : " << line.getLength() <<endl;
   // 再次设置长度
   line.setLength(6.0); 
   cout << "Length of line : " << line.getLength() <<endl;
 
   return 0;
}

>>Object is being created, length = 10
Length of line : 10
Length of line : 6

使用初始化列表来初始化字段

Line::Line( double len): length(len)
{
    cout << "Object is being created, length = " << len << endl;
}

上面的语法等同于如下语法：

Line::Line( double len)
{
    length = len;
    cout << "Object is being created, length = " << len << endl;
}

假设有一个类 C，具有多个字段 length、width、height等需要进行初始化，同理地，您可以使用上面的语法，只需要在不同的字段使用逗号进行分隔，如下所示：

C::C( double a, double b, double c): length(a), width(b), height(c)
{
  ....
}

类的析构函数

类的析构函数是类的一种特殊的成员函数，它会在每次删除所创建的对象时执行。

析构函数的名称与类的名称是完全相同的，只是在前面加了个波浪号（~）作为前缀，它不会返回任何值，也不能带有任何参数。析构函数有助于在跳出程序（比如关闭文件、释放内存等）前释放资源。

下面的实例有助于更好地理解析构函数的概念：

#include <iostream>
using namespace std;
 
class Line
{
   public:
      void setLength( double len );
      double getLength( void );
      Line();   // 这是构造函数声明
      ~Line();  // 这是析构函数声明
 
   private:
      double length;
};
 
// 成员函数定义，包括构造函数
Line::Line(void)
{
    cout << "Object is being created" << endl;
}
Line::~Line(void)
{
    cout << "Object is being deleted" << endl;
}
 
void Line::setLength( double len )
{
    length = len;
}
 
double Line::getLength( void )
{
    return length;
}
// 程序的主函数
int main( )
{
   Line line;
   // 设置长度
   line.setLength(6.0); 
   cout << "Length of line : " << line.getLength() <<endl;
 
   return 0;
}

>>Object is being created
Length of line : 6
Object is being deleted

类的构造函数 & 析构函数

类的构造函数

类的构造函数是类的一种特殊的成员函数，

• 它会在每次创建类的新对象时执行。
• 构造函数的名称与类的名称是完全相同的
• 不会返回任何类型，也不会返回 void。
• 构造函数可用于为某些成员变量设置初始值
• 注意构造函数没有前缀

#include <iostream>

using namespace std;
class Line	// 成员函数定义，包括构造函数
{
   public:
      void setLength( double len );
      double getLength( void );
      Line();  // 这是构造函数
   private:
      double length;
};
Line::Line(void)
{
    cout << "Object is being created" << endl;
}
 
void Line::setLength( double len )
{
    length = len;
}
 
double Line::getLength( void )
{
    return length;
}
// 程序的主函数
int main( )
{
   Line line;
   // 设置长度
   line.setLength(6.0); 
   cout << "Length of line : " << line.getLength() <<endl;
 
   return 0;
}

输出：

Object is being created
Length of line : 6

带参数的构造函数

默认的构造函数没有任何参数，但如果需要，构造函数也可以带有参数。
这样在创建对象时就会给对象赋初始值

#include <iostream>
 
using namespace std;
 
class Line
{
   public:
      void setLength( double len );
      double getLength( void );
      Line(double len);  // 这是构造函数
 
   private:
      double length;
};
 
// 成员函数定义，包括构造函数
Line::Line( double len)
{
    cout << "Object is being created, length = " << len << endl;
    length = len;
}
 
void Line::setLength( double len )
{
    length = len;
}
 
double Line::getLength( void )
{
    return length;
}
// 程序的主函数
int main( )
{
   Line line(10.0);
 
   // 获取默认设置的长度
   cout << "Length of line : " << line.getLength() <<endl;
   // 再次设置长度
   line.setLength(6.0); 
   cout << "Length of line : " << line.getLength() <<endl;
 
   return 0;
}

输出：

Object is being created, length = 10
Length of line : 10
Length of line : 6

⭐使用初始化列表来初始化字段

使用初始化列表来初始化字段：
初始化数据 length = 输入的形参 len

Line::Line( double len): length(len)
{
    cout << "Object is being created, length = " << len << endl;
}

上面的语法等同于如下语法：

Line::Line( double len)
{
    length = len;
    cout << "Object is being created, length = " << len << endl;
}

假设有一个类 C，具有多个字段 X、Y、Z 等需要进行初始化，同理地，您可以使用上面的语法，只需要在不同的字段使用逗号进行分隔，如下所示：

C::C( double a, double b, double c): X(a), Y(b), Z(c)
{
  ....
}

上述操作等价于

C::C( double a, double b, double c)
{
	X = a; 
	Y = b;
	Z = c;
}

代码示例

#include <iostream>

using namespace std;

class Line
{
public:
    void setLength( double len );
    
    double getLength( void );
    double getWidth( void );
    double getHigh( void );
    double getBox( void );
    Line(double len,double wid,double hig);  // 这是构造函数

private:
    double length;
    double width;
    double high;
    double box;
};

// 成员函数定义，包括构造函数
Line::Line( double len,double wid,double hig):length(len),width(wid),high(hig)
{
    cout << "Object is being created, length = " << len << endl;
}
void Line::setLength( double len )
{
    length = len;
}
double Line::getLength( void )
{
    return length;
}
double Line::getWidth(void )
{
    return width;
}
double Line::getHigh()
{
    return high;
}
double Line::getBox()
{
    return (length*width*high);
}
// 程序的主函数
int main( )
{
    Line line(8.0,8.0,8.0);
    // 获取默认设置的长度
    cout << "Length of line : " << line.getBox() <<endl;
    // 再次设置长度
    line.setLength(6.0);
    cout << "Length of line : " << line.getBox() <<endl;
    return 0;
}

运行输出

Object is being created, length = 8
Length of line : 512
Length of line : 384

⭐类的析构函数

类的析构函数是类的一种特殊的成员函数，它会在每次删除所创建的对象时执行。析构函数的名称与类的名称是完全相同的，只是在前面加了个波浪号（~）作为前缀，它不会返回任何值，也不能带有任何参数。析构函数有助于在跳出程序（比如关闭文件、释放内存等）前释放资源。

#include <iostream>
using namespace std;
class Line
{
   public:
      void setLength( double len );
      double getLength( void );
      Line();   // 这是构造函数声明
      ~Line();  // 这是析构函数声明
 
   private:
      double length;
};
 
// 成员函数定义，包括构造函数
Line::Line(void)
{
    cout << "Object is being created" << endl;
}
Line::~Line(void)
{
    cout << "Object is being deleted" << endl;
}
 
void Line::setLength( double len )
{
    length = len;
}
 
double Line::getLength( void )
{
    return length;
}
// 程序的主函数
int main( )
{
   Line line;
 
   // 设置长度
   line.setLength(6.0); 
   cout << "Length of line : " << line.getLength() <<endl;
 
   return 0;
}

输出：

Object is being created
Length of line : 6
Object is being deleted