C++构造函数

无参构造函数

首先创造一个Entity类，在类里面有两个变量x, y以及一个方法

#include <iostream>

class Entity{
public:
    float X, Y;

    void Print(){
        std::cout << X << ", " << Y << std::endl;
    }
};

int main() {

    Entity e;
    std::cout << e.X << std::endl;//会出现警告，使用未初始化的值
    e.Print(); //会打印出 X,Y的值



    std::cin.get();
    return 0;
}

所以我们需要一种方法，当构造Entity实例时，我们想要把X,Y设为零，除非已经指定了其他的值。

1. 方法一，定义一个Init()函数进行初始化

   #include <iostream>
   
   class Entity{
   public:
       float X, Y;
   
       void Init(){//定义了初始化的方法
           X = 0.0f;
           Y = 0.0f;
       }
       void Print(){
           std::cout << X << ", " << Y << std::endl;
       }
   };
   
   int main() {
   
       Entity e;
       e.Init();
       std::cout << e.X << std::endl;//会出现警告，使用未初始化的值
       e.Print(); //会打印出 X,Y的值
       
       std::cin.get();
       return 0;
   }
   
   

2. 构造函数方法
   是一种特殊类型的方法，每次你构造一个对象时，都会调用的方法，没有返回类型，并且他的名称必须与类的名称相同

   #include <iostream>
   
   class Entity{
   public:
       float X, Y;
   
       Entity(){		//构造函数
           X = 0.0f;
           Y = 0.0f;
       }
   
       void Print(){
           std::cout << X << ", " << Y << std::endl;
       }
   };
   
   int main() {
   
       Entity e;
       std::cout << e.X << std::endl;//会打印出 X,Y的值
       e.Print(); //会打印出 X,Y的值
   
       std::cin.get();
       return 0;
   }
   
   

3. 如果没有指定构造函数，实际上会有默认的构造函数，但是它实际上什么都不会做

   class Entity{
   public:
       float X, Y;
   
       Entity(){//默认构造函数
          
       }
   
       void Print(){
           std::cout << X << ", " << Y << std::endl;
       }
   };
   

有参构造函数

一个类里面可以有很多构造函数，前提是他们的参数不同，实际上，这就是函数的重载。

#include <iostream>

class Entity{
public:
    float X, Y;

    Entity(){

    }
    Entity(float x, float y){
        X = x;
        Y = y;
    }

    void Print(){
        std::cout << X << ", " << Y << std::endl;
    }
};

int main() {

    Entity e(10.0f, 5.0f); //这里调用了有参构造器

    e.Print(); //会打印出 10, 5

    std::cin.get();
    return 0;
}

拒绝用户进行实例化

当不想让用户对类进行实例化的时候，也就是只能通过作用域类进行可以通过隐藏构造函数

class Log{
private:
    Log(){

    }
public:
    static void Write(){

    }
};
int main() {

    Log::Write();//只能使用这种方法
    Log L;//这里会报错，显示调用私有构造器

}

默认构造器删除

cpp为我们提供了默认构造器，但我们可以选择不要他

class Log{

public:
    Log() = delete;//这句表示删除默认构造器
    
    static void Write(){

    }
};
int main() {

    Log::Write();//只能使用这种方法
    Log L;// 这里会出错，因为默认构造器不存在

}

可以这样思考，对一个类进行实例化的时候，必须有构造器，CPP为我们提供了默认的构造器，但是他什么都不会做。

C++析构函数

销毁对象时候使用，卸载变量等东西，并清理使用过的内存

#include <iostream>

class Entity{
public:
    float X, Y;

    Entity(){
        X = 0.0f;
        Y = 0.0f;
        std::cout << "Created Entity!" << std::endl;
    }
    Entity(float x, float y){
        X = x;
        Y = y;
    }

    ~Entity(){
        std::cout << "Destroyed Eneity!" << std::endl;
    }
    void Print(){
        std::cout << X << ", " << Y << std::endl;
    }
};

void Function(){
    Entity e;
    e.Print(); 
}
int main() {
    Function();
    std::cin.get();
    return 0;
}