C++随笔之类的构造函数-CSDN博客

1. C++构造函数的作用

~ 创建类的对象

~ 如果是普通构造函数，初始化类对象下所有成员数据

~ 如果是拷贝构造函数，将已有的类对象下的所有成员数据复制一份，给新对象下的所有成员一一对应赋值

2. C++构造函数的特点

~ 不用函数那样前面必须加void类型或返回值的数据类型

~ 构造函数的名称必须和类型名称保持一致

~ 构造函数可以支持重载

3. C++构造函数的分类

~ 普通构造函数

● 无参构造函数

● 有参构造函数

~ 拷贝构造函数

4. C++构造函数实现和调用代码示例

#include<iostream>
#include<string>

using namespace std;

class User
{
private:
	string _name;
	int _age;
public:
	/*
	* 无参构造函数
	*/
	User()
	{
		_name = "";
		_age = 0;
	}
	/*
	* 有参数的构造函数(也是重载的构造函数)
	*/
	User(string name)
	{
		_name = name;
		//默认永远18
		_age = 18;
	}
	User(string name, int age)
	{
		_name = name;
		_age = age;
	}
	/*
	* 拷贝构造函数
	*	注意: 
	*		拷贝构造函数的参数声明格式必须是 const + 引用(引用的类型必须和当前类的类型保持一致) + 变量名称
	*		只有格式严格按照上述所写才叫做拷贝构造函数
	*/
	User(const User& other)
	{
		this->_name = other._name;
		this->_age = other._age;
	}
	string getName()
	{
		return _name;
	}
	void setName(string name)
	{
		_name = name;
	}
	int getAge()
	{
		return _age;
	}
	void setAge(int age)
	{
		_age = age;
	}
	string toString()
	{
		return "Name: " + _name + ", Age: " + to_string(_age);
	}
};

int main()
{
	/*
	* 构造函数的调用方式
	*/

	/*
	* 1. 括号法
	*	注意:
	*		调用无参构造函数时, 不要在变量后面加括号, 会被编译器误认为是函数的声明
	*/
	// 调用无参构造函数
	User u;
	u.setName("Sam");
	u.setAge(21);
	cout << "对象u: " << u.toString() << endl;
	// 调用有参构造函数
	User u2("Daming", 20);
	cout << "对象u2: " << u2.toString() << endl;
	// 调用拷贝构造函数
	User u3(u);
	cout << "对象3: " << u3.toString() << endl;

	/*
	* 2. 显示法
	*/
	// 调用无参构造函数
	User user = User();
	user.setName("Lili");
	user.setAge(23);
	cout << "对象user: " << user.toString() << endl;
	// 调用有参构造函数
	User user2 = User("Lucy", 20);
	cout << "对象user2: " << user2.toString() << endl;
	// 调用拷贝构造函数
	User user3 = User(user);
	cout << "对象user3: " << user3.toString() << endl;

	/*
	* 3. 隐式法
	*	注意: 只有参数个数是一个的时候才可以这么使用
	*/
	// 调用有参构造函数
	User u_1 = string("Tom");
	cout << "对象u_1: " << u_1.toString() << endl;
	// 调用拷贝构造函数
	User u_2 = u_1;
	cout << "对象u_2: " << u_2.toString() << endl;

	/*
	* 如果想要将类对象存储于内存堆中, 使用new关键字与显示法的调用方式结合使用
	*/
	User* user_p = new User("镇元斋", 80);
	cout << "存储于内存堆中的对象user_p: " << user_p->toString() << endl;
	//释放堆中对象
	delete user_p;

	return 0;
}

5. C++编译器默认提供构造函数的特点

~ 如果类中没有写任何构造函数，那么编译器会默认提供一个无参构造函数和一个拷贝构造函数

#include<iostream>
#include<string>

using namespace std;

class User
{
public:
    string name;
    int age;
    string toString()
    {
        return "Name: " + name + ", Age: " + to_string(age);
    }
};

int main()
{
    /*
    * 在类中没有写任何构造函数的情况下，依旧可以调用默认的无参构造函数
    */
    User u = User();
    u.name = "Sam";
    u.age = 20;
    cout << "对象u的信息: " << u.toString() << endl;

    /*
    * 在类中没有写任何构造函数的情况下，依旧可以调用拷贝构造函数
    */
    User u2 = User(u);
    cout << "对象u2的信息: " << u.toString() << endl;

    return 0;
}

~ 如果类中只写了无参构造函数或有参构造函数，编译器不会再提供默认的无参构造函数，但是依旧会提供默认的拷贝构造函数

#include<iostream>
#include<string>

using namespace std;

class User
{
public:
    string name;
    int age;
    User(string name, int age)
    {
        this->name = name;
        this->age = age;
    }
    string toString()
    {
        return "Name: " + name + ", Age: " + to_string(age);
    }
};

int main()
{
    /*
    * 编译性错误，因为已经提供了一个有参构造函数，所以编译器不会再提供一个默认的无参构造函数
    */
    User u = User();
    u.name = "Sam";
    u.age = 20;
    cout << "对象u的信息: " << u.toString() << endl;

    /*
    * 在类中没有声明拷贝构造函数的情况下，依旧可以调用拷贝构造函数
    */
    User u2 = User(u);
    cout << "对象u2的信息: " << u.toString() << endl;

    return 0;
}

~ 如果类中只写了拷贝构造函数，编译器就不会再提供默认的无参构造函数和默认的拷贝构造函数

#include<iostream>
#include<string>

using namespace std;

class User
{
public:
    string name;
    int age;
    /*
    * 拷贝构造函数
    */
    User(const User& other)
    {
        this->name = other.name;
        this->age = other.age;
    }
    string toString()
    {
        return "Name: " + name + ", Age: " + to_string(age);
    }
};

int main()
{
    /*
    * 编译性错误，因为User类中已经设置了拷贝构造函数，编译器无法再提供默认的无参构造函数
    */
    User u = User();

    return 0;
}