c++学习五（构造函数）

最新推荐文章于 2023-09-13 21:18:34 发布
最新推荐文章于 2023-09-13 21:18:34 发布
阅读量296 收藏 1
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wllen_/article/details/81591397
版权

在原来的程序中，首先在类里面包含了成员属性并且包含了用来初始化成员属性的一些设置函数，然后在main函数中调用这些设置函数来对这些属性赋值。而且每设置一个属性就要调用一个函数，这样看起来很麻烦效率很低。

因此引入了构造函数。

所谓构造函数就是和类的名字相同的函数，它可以带有参数，也可以带参数，也可以带不同的参数（利用了函数的重载）。

在类中写好了构造函数之后，在使用类定义对象的同时把要赋值给对象的属性的值作为参数同时传进去，那么程序就会自动去调用相应的构造函数（利用函数的重载来区分具体调用那个构造函数（利用的函数重载的属性，通过函数的参数的类型、个数、参数顺序不一样来区分））。

如果在使用类定义对象的时候没有传进去参数那么就调用没有带参数的那个构造函数。

如果想在定义对象的时候不传进去参数就不应该带括号

Person per;      /*调用无参构造函数*/   Person是一个类，定义了一个对象per，在定义这个对象的同时会调用不带参数的那个构造函数。

在C语言和C++语言中，圆括号（）就代表函数的调用。

Person per();     /*int fun()*/    这段代码代表一段函数的声明函数名为per    参数为void无参数   返回值为Person类

#include <iostream>

using namespace std;

class Person
{
private:
    char *name;
    int age;
    char *work;

public:
    Person()
    {
        cout<<"Person()"<<endl;
    }

    Person(char *name)
    {
        cout<<"Person(char *name)"<<endl;
        this->name = name;
    }


    Person(char *name, int age, char *work = "none")
    {
        cout<<"Person(char *name, int age, cahr *work)"<<endl;
        this->name = name;
        this->age = age;
        this->work = work;
    }

    void printInfo(void)
    {
        cout<<"name = "<<name<<"  age = "<<age<<"  work = "<<work<<endl;
    }
};

int main(void)
{
    Person per;               /*调用无参构造函数来实例化对象*/
    Person per2("zhangsan");  /*调用只有一个参数的构造函数*/
    Person per3("lisi", 20);  /*调用两个参数的构造函数*/
    Person per4("wangwu", 30, "teacher");

    /*也可以用new来创建动态对象*/
    Person *per5 = new Person();
    Person *per6 = new Person[2];
    Person *per7 = new Person("wangwu", 20, "student");

    per2.printInfo();
    per3.printInfo();
    per4.printInfo();
    per7->printInfo();
    /*最后要用delete来释放动态创建的对象*/
 
    delete per5;
    delete []per6;
}

 

利用动态内存分配来保存属性的值

class Person
{
private:
    char *name;
    int age;
    char *work;

public:
    Person()
    {
        cout<<"Person()"<<endl;
    }

    Person(char *name)
    {
        cout<<"Person(char *name)"<<endl;
        this->name = new char[strlen(name) + 1];
        strcpy(this->name, name);
    }


    Person(char *name, int age, char *work = "none")
    {
        cout<<"Person(char *name, int age, cahr *work)"<<endl;

        this->name = new char[strlen(name) + 1];
        strcpy(this->name, name);

        this->age = age;

        this->work= new char[strlen(work) + 1];
        strcpy(this->work, work);
    }

    void printInfo(void)
    {
        cout<<"name = "<<name<<"  age = "<<age<<"  work = "<<work<<endl;
    }
};

分配了堆内存之后在如果没有手动释放，在程序运行结束后操作系统会自动回收堆内存。

但是如果我们分配的堆内存在一个子函数中，当调用这个子函数分配了堆内存，子函数执行完之后并不会释放之前申请的堆内存，这样随着程序的运行时间越长内存的消耗就越大，就会造成内存泄漏。

我们自己可以在类里面定义一个函数用来释放申请过的堆内存，当函数结束之前调用这个释放堆内存的函数。但是这样每个对象都要调用一次这个函数。显得太麻烦了。所以引入了析构函数。在实例化对象销毁的瞬间系统会调用析构函数。可以有很多个构造函数，但是只有一个析构函数并且是不带参数的

如果用new创建的空间应该要用delete来释放才能调用这个对象的析构函数。否则当程序结束释放这个new出来的堆空间不会调用析构函数。

默认拷贝构造函数

Person(Person &per); 

定义了一个有参数的构造函数一定要提供一个无参数的构造函数。 

 

 

person.cpp


#include <iostream>
using namespace std;

class Person {
private:
	char *name;
	int age;
	char *work;

public:

	Person() {cout <<"Pserson()"<<endl;}
	Person(char *name) 
	{
		cout <<"Pserson(char *)"<<endl;
		this->name = name;
	}

	Person(char *name, int age) 
	{
		cout <<"Pserson(char*, int)"<<endl;
		this->name = name;
		this->age = age;
	}
	
	void setName(char *n)
	{
		name = n;
	}
	int setAge(int a)
	{
		if (a < 0 || a > 150)
		{
			age = 0;
			return -1;
		}
		age = a;
		return 0;
	}
	void printInfo(void)
	{
		//printf("name = %s, age = %d, work = %s\n", name, age, work); 
		cout<<"name = "<<name<<", age = "<<age<<", work = "<<work<<endl;
	}
};

int main(int argc, char **argv)
{
	Person per("zhangsan", 16);
	Person per2;

	per.printInfo();
	
	return 0;
}

 程序分析：在main函数中使用类Person实例化对象per并且传入两个参数，所以会调用对象per的带有两个参数的构造函数。

                     在定义对象per2的时候没有传入参数所以会调用无参的构造函数

打印信息：

Pserson(char*, int)
Pserson()
name = zhangsan, age = 16, work = ��c�      /*work没初始化所以是乱码*/
 

 

person2.cpp


#include <iostream>
using namespace std;

class Person {
private:
	char *name;
	int age;
	char *work;

public:

	Person() {cout <<"Pserson()"<<endl;}
	Person(char *name) 
	{
		cout <<"Pserson(char *)"<<endl;
		this->name = name;
	}

	Person(char *name, int age, char *work = "none") 
	{
		cout <<"Pserson(char*, int)"<<endl;
		this->name = name;
		this->age = age;
		this->work = work;
	}

	
	void setName(char *n)
	{
		name = n;
	}
	int setAge(int a)
	{
		if (a < 0 || a > 150)
		{
			age = 0;
			return -1;
		}
		age = a;
		return 0;
	}
	void printInfo(void)
	{
		//printf("name = %s, age = %d, work = %s\n", name, age, work); 
		cout<<"name = "<<name<<", age = "<<age<<", work = "<<work<<endl;
	}
};

int main(int argc, char **argv)
{
	Person per("zhangsan", 16);
	Person per2;   /* 调用无参构造函数 */
	Person per3(); /* int fun(); */

	per.printInfo();
	return 0;
}

程序分析：实例化per对象会调用三个参数的构造函数，如果传入两个参数则第三个参数值为none

                    实例化per2会调用无参构造函数

                    第三条语句是一个函数的声明。声明一个函数名为per3返回值为Person不带参数的函数。

打印信息：

Pserson(char*, int)
Pserson()
name = zhangsan, age = 16, work = none
 

 

person3.cpp


#include <iostream>
using namespace std;

class Person {
private:
	char *name;
	int age;
	char *work;

public:

	Person() {cout <<"Pserson()"<<endl;}
	Person(char *name) 
	{
		cout <<"Pserson(char *)"<<endl;
		this->name = name;
	}

	Person(char *name, int age, char *work = "none") 
	{
		cout <<"Pserson(char*, int)"<<endl;
		this->name = name;
		this->age = age;
		this->work = work;
	}

	
	void setName(char *n)
	{
		name = n;
	}
	int setAge(int a)
	{
		if (a < 0 || a > 150)
		{
			age = 0;
			return -1;
		}
		age = a;
		return 0;
	}
	void printInfo(void)
	{
		//printf("name = %s, age = %d, work = %s\n", name, age, work); 
		cout<<"name = "<<name<<", age = "<<age<<", work = "<<work<<endl;
	}
};

int main(int argc, char **argv)
{
	Person per("zhangsan", 16);
	Person per2;   /* 调用无参构造函数 */
	Person per3(); /* int fun(); */

	Person *per4 = new Person;
	Person *per5 = new Person();

	Person *per6 = new Person[2];

	Person *per7 = new Person("lisi", 18, "student");
	Person *per8 = new Person("wangwu", 18);

	per.printInfo();
	per7->printInfo();
	per8->printInfo();

	delete per4;
	delete per5;
	delete []per6;
	delete per7;
	delete per8;

	return 0;
}

程序分析：相比如之前的程序，先在利用堆内存来个对象分配空间，在使用完后要手动delete堆内存空间。并且因为定义的时候是使用指针来指向堆内存空间的所以在引用对象中的属性或者函数的时候要用符号“->”。

 

打印结果：

Pserson(char*, int)
Pserson()
Pserson()
Pserson()
Pserson()
Pserson()
Pserson(char*, int)
Pserson(char*, int)
name = zhangsan, age = 16, work = none
name = lisi, age = 18, work = student
name = wangwu, age = 18, work = none
 

person4.cpp


#include <iostream>
#include <string.h>

using namespace std;

class Person {
private:
	char *name;
	int age;
	char *work;

public:

	Person() {cout <<"Pserson()"<<endl;}
	Person(char *name) 
	{
		cout <<"Pserson(char *)"<<endl;
		this->name = new char[strlen(name) + 1];
		strcpy(this->name, name);
	}

	Person(char *name, int age, char *work = "none") 
	{
		cout <<"Pserson(char*, int)"<<endl;
		this->age = age;

		this->name = new char[strlen(name) + 1];
		strcpy(this->name, name);

		this->work = new char[strlen(work) + 1];
		strcpy(this->work, work);
	}

	
	void setName(char *n)
	{
		name = n;
	}
	int setAge(int a)
	{
		if (a < 0 || a > 150)
		{
			age = 0;
			return -1;
		}
		age = a;
		return 0;
	}
	void printInfo(void)
	{
		//printf("name = %s, age = %d, work = %s\n", name, age, work); 
		cout<<"name = "<<name<<", age = "<<age<<", work = "<<work<<endl;
	}
};

int main(int argc, char **argv)
{
	Person per("zhangsan", 16);
	Person per2;   /* 调用无参构造函数 */
	Person per3(); /* int fun(); */

	Person *per4 = new Person;
	Person *per5 = new Person();

	Person *per6 = new Person[2];

	Person *per7 = new Person("lisi", 18, "student");
	Person *per8 = new Person("wangwu", 18);

	per.printInfo();
	per7->printInfo();
	per8->printInfo();

	delete per4;
	delete per5;
	delete []per6;
	delete per7;
	delete per8;

	return 0;
}

程序分析：对象的属性使用堆内存来保存属性的值。申请空间的大小的时候要注意分配多一个字节的空间给字符结束符'\0'。

 

person5.cpp


#include <iostream>
#include <string.h>
#include <unistd.h>

using namespace std;

class Person {
private:
	char *name;
	int age;
	char *work;

public:

	Person() {//cout <<"Pserson()"<<endl;
		name = NULL;
		work = NULL;
	}
	Person(char *name) 
	{
		//cout <<"Pserson(char *)"<<endl;
		this->name = new char[strlen(name) + 1];
		strcpy(this->name, name);
		this->work = NULL;
	}

	Person(char *name, int age, char *work = "none") 
	{
		//cout <<"Pserson(char*, int)"<<endl;
		this->age = age;

		this->name = new char[strlen(name) + 1];
		strcpy(this->name, name);

		this->work = new char[strlen(work) + 1];
		strcpy(this->work, work);
	}

	void setName(char *n)
	{
		name = n;
	}
	int setAge(int a)
	{
		if (a < 0 || a > 150)
		{
			age = 0;
			return -1;
		}
		age = a;
		return 0;
	}
	void printInfo(void)
	{
		//printf("name = %s, age = %d, work = %s\n", name, age, work); 
		//cout<<"name = "<<name<<", age = "<<age<<", work = "<<work<<endl;
	}
};

void test_fun()
{
	Person per("zhangsan", 16);
	Person per2;   /* 调用无参构造函数 */
	Person per3(); /* int fun(); */

	Person *per4 = new Person;
	Person *per5 = new Person();

	Person *per6 = new Person[2];

	Person *per7 = new Person("lisi", 18, "student");
	Person *per8 = new Person("wangwu", 18);

	per.printInfo();
	per7->printInfo();
	per8->printInfo();

	delete per4;
	delete per5;
	delete []per6;
	delete per7;
	delete per8;

}

int main(int argc, char **argv)
{
	for (int i = 0; i < 1000000; i++)
		test_fun();
	cout << "run test_fun end"<<endl;
	sleep(10);
	return 0;
}

程序分析：因为在对象销毁之前没有释放对象内部属性所申请的堆内存，所以在程序运行期间会造成内存泄漏。

 

person6.cpp


#include <iostream>
#include <string.h>
#include <unistd.h>

using namespace std;

class Person {
private:
	char *name;
	int age;
	char *work;

public:

	Person() {//cout <<"Pserson()"<<endl;
		name = NULL;
		work = NULL;
	}
	Person(char *name) 
	{
		//cout <<"Pserson(char *)"<<endl;
		this->name = new char[strlen(name) + 1];
		strcpy(this->name, name);
		this->work = NULL;
	}

	Person(char *name, int age, char *work = "none") 
	{
		//cout <<"Pserson(char*, int)"<<endl;
		this->age = age;

		this->name = new char[strlen(name) + 1];
		strcpy(this->name, name);

		this->work = new char[strlen(work) + 1];
		strcpy(this->work, work);
	}

	~Person()
	{
		if (this->name)
			delete this->name;
		if (this->work)
			delete this->work;
	}

	void setName(char *n)
	{
		name = n;
	}
	int setAge(int a)
	{
		if (a < 0 || a > 150)
		{
			age = 0;
			return -1;
		}
		age = a;
		return 0;
	}
	void printInfo(void)
	{
		//printf("name = %s, age = %d, work = %s\n", name, age, work); 
		//cout<<"name = "<<name<<", age = "<<age<<", work = "<<work<<endl;
	}
};

void test_fun()
{
	Person per("zhangsan", 16);
	Person per2;   /* 调用无参构造函数 */
	Person per3(); /* int fun(); */

	Person *per4 = new Person;
	Person *per5 = new Person();

	Person *per6 = new Person[2];

	Person *per7 = new Person("lisi", 18, "student");
	Person *per8 = new Person("wangwu", 18);

	per.printInfo();
	per7->printInfo();
	per8->printInfo();

	delete per4;
	delete per5;
	delete []per6;
	delete per7;
	delete per8;

}

int main(int argc, char **argv)
{
	for (int i = 0; i < 1000000; i++)
		test_fun();
	cout << "run test_fun end"<<endl;
	sleep(10);
	return 0;
}

程序分析：程序中添加了析构函数，析构函数就是~Person()这个函数，波浪线+类的名字并且不带参数，当对象在销毁之前会调用这个析构函数，析构函数只有一个，构造函数可以有多个。所以这个程序不会有内存泄漏。

 

person7.cpp


#include <iostream>
#include <string.h>
#include <unistd.h>

using namespace std;

class Person {
private:
	char *name;
	int age;
	char *work;

public:

	Person() {//cout <<"Pserson()"<<endl;
		name = NULL;
		work = NULL;
	}
	Person(char *name) 
	{
		//cout <<"Pserson(char *)"<<endl;
		this->name = new char[strlen(name) + 1];
		strcpy(this->name, name);
		this->work = NULL;
	}

	Person(char *name, int age, char *work = "none") 
	{
		//cout <<"Pserson(char*, int)"<<endl;
		this->age = age;

		this->name = new char[strlen(name) + 1];
		strcpy(this->name, name);

		this->work = new char[strlen(work) + 1];
		strcpy(this->work, work);
	}

	~Person()
	{
		cout << "~Person()"<<endl;
		if (this->name) {
			cout << "name = "<<name<<endl;
			delete this->name;
		}
		if (this->work) {
			cout << "work = "<<work<<endl;
			delete this->work;
		}
	}

	void setName(char *n)
	{
		name = n;
	}
	int setAge(int a)
	{
		if (a < 0 || a > 150)
		{
			age = 0;
			return -1;
		}
		age = a;
		return 0;
	}
	void printInfo(void)
	{
		//printf("name = %s, age = %d, work = %s\n", name, age, work); 
		//cout<<"name = "<<name<<", age = "<<age<<", work = "<<work<<endl;
	}
};

void test_fun()
{
	Person per("zhangsan", 16);

	Person *per7 = new Person("lisi", 18, "student");
	//delete per7;

}

int main(int argc, char **argv)
{
	test_fun();
	cout << "run test_fun end"<<endl;
	sleep(10);
	return 0;
}

程序分析：当对象被销毁之前会调用析构函数。但是使用了new为对象分配堆空间而没有delete等程序退出的时候是不会调用析构函数的。

只有调用了delete之后才会调用析构函数。

所以打印结果：/*只调用了per这个对象的析构函数*/

~Person()
name = zhangsan
work = none
run test_fun end

 

person8.cpp


#include <iostream>
#include <string.h>
#include <unistd.h>

using namespace std;

class Person {
private:
	char *name;
	int age;
	char *work;

public:

	Person() {//cout <<"Pserson()"<<endl;
		name = NULL;
		work = NULL;
	}
	Person(char *name) 
	{
		//cout <<"Pserson(char *)"<<endl;
		this->name = new char[strlen(name) + 1];
		strcpy(this->name, name);
		this->work = NULL;
	}

	Person(char *name, int age, char *work = "none") 
	{
		//cout <<"Pserson(char*, int)"<<endl;
		this->age = age;

		this->name = new char[strlen(name) + 1];
		strcpy(this->name, name);

		this->work = new char[strlen(work) + 1];
		strcpy(this->work, work);
	}

	~Person()
	{
		cout << "~Person()"<<endl;
		if (this->name) {
			cout << "name = "<<name<<endl;
			delete this->name;
		}
		if (this->work) {
			cout << "work = "<<work<<endl;
			delete this->work;
		}
	}

	void setName(char *n)
	{
		name = n;
	}
	int setAge(int a)
	{
		if (a < 0 || a > 150)
		{
			age = 0;
			return -1;
		}
		age = a;
		return 0;
	}
	void printInfo(void)
	{
		//printf("name = %s, age = %d, work = %s\n", name, age, work); 
		cout<<"name = "<<name<<", age = "<<age<<", work = "<<work<<endl;
	}
};

int main(int argc, char **argv)
{
	Person per("zhangsan", 18);
	Person per2(per);

	per2.printInfo();

	return 0;
}

程序分析：默认拷贝构造函数，将per2的对象的属性的指针也指向了per对象的属性的指针所指向的内存空间，所以当这两个对象销毁的时候会调用两次析构函数，然后对同一个内存区域释放两次。

打印结果：

name = zhangsan, age = 18, work = none
~Person()
name = zhangsan
work = none
~Person()
name =                   /*因为上面已经释放了这两个指针指向的内存区域，所以没东西打印出来*/
work = 

 

person9.cpp


#include <iostream>
#include <string.h>
#include <unistd.h>

using namespace std;

class Person {
private:
	char *name;
	int age;
	char *work;

public:

	Person() {//cout <<"Pserson()"<<endl;
		name = NULL;
		work = NULL;
	}
	Person(char *name) 
	{
		//cout <<"Pserson(char *)"<<endl;
		this->name = new char[strlen(name) + 1];
		strcpy(this->name, name);
		this->work = NULL;
	}

	Person(char *name, int age, char *work = "none") 
	{
		//cout <<"Pserson(char*, int)"<<endl;
		this->age = age;

		this->name = new char[strlen(name) + 1];
		strcpy(this->name, name);

		this->work = new char[strlen(work) + 1];
		strcpy(this->work, work);
	}

	Person(Person &per) 
	{
		cout <<"Pserson(Person &)"<<endl;
		this->age = per.age;

		this->name = new char[strlen(per.name) + 1];
		strcpy(this->name, per.name);

		this->work = new char[strlen(per.work) + 1];
		strcpy(this->work, per.work);
	}

	~Person()
	{
		cout << "~Person()"<<endl;
		if (this->name) {
			cout << "name = "<<name<<endl;
			delete this->name;
		}
		if (this->work) {
			cout << "work = "<<work<<endl;
			delete this->work;
		}
	}

	void setName(char *n)
	{
		name = n;
	}
	int setAge(int a)
	{
		if (a < 0 || a > 150)
		{
			age = 0;
			return -1;
		}
		age = a;
		return 0;
	}
	void printInfo(void)
	{
		//printf("name = %s, age = %d, work = %s\n", name, age, work); 
		cout<<"name = "<<name<<", age = "<<age<<", work = "<<work<<endl;
	}
};

int main(int argc, char **argv)
{
	Person per("zhangsan", 18);
	Person per2(per);

	per2.printInfo();

	return 0;
}

程序分析：自己写了一个拷贝构造函数，利用了引用把per对象的属性的值都传给per2对象的属性。两个对象的属性的指针都分别指向不同的内存空间。

打印结果：

Pserson(Person &)
name = zhangsan, age = 18, work = none
~Person()
name = zhangsan
work = none
~Person()
name = zhangsan
work = none
 

person10.cpp


#include <iostream>
#include <string.h>
#include <unistd.h>

using namespace std;

class Person {
private:
	char *name;
	int age;
	char *work;

public:

	Person() {
		cout <<"Pserson()"<<endl;
		name = NULL;
		work = NULL;
	}
	Person(char *name) 
	{
		//cout <<"Pserson(char *)"<<endl;
		this->name = new char[strlen(name) + 1];
		strcpy(this->name, name);
		this->work = NULL;
	}

	Person(char *name, int age, char *work = "none") 
	{
		cout <<"Pserson(char*, int), name = "<<name<<", age= "<<age<<endl;
		this->age = age;

		this->name = new char[strlen(name) + 1];
		strcpy(this->name, name);

		this->work = new char[strlen(work) + 1];
		strcpy(this->work, work);
	}

	Person(Person &per) 
	{
		cout <<"Pserson(Person &)"<<endl;
		this->age = per.age;

		this->name = new char[strlen(per.name) + 1];
		strcpy(this->name, per.name);

		this->work = new char[strlen(per.work) + 1];
		strcpy(this->work, per.work);
	}

	~Person()
	{
		cout << "~Person()"<<endl;
		if (this->name) {
			cout << "name = "<<name<<endl;
			delete this->name;
		}
		if (this->work) {
			cout << "work = "<<work<<endl;
			delete this->work;
		}
	}

	void setName(char *n)
	{
		name = n;
	}
	int setAge(int a)
	{
		if (a < 0 || a > 150)
		{
			age = 0;
			return -1;
		}
		age = a;
		return 0;
	}
	void printInfo(void)
	{
		//printf("name = %s, age = %d, work = %s\n", name, age, work); 
		cout<<"name = "<<name<<", age = "<<age<<", work = "<<work<<endl;
	}
};

class Student {
private:
	Person father;
	Person mother;
	int student_id;
public:
	Student()
	{
		cout<<"Student()"<<endl;
	}

	Student(int id, char *father, char *mother, int father_age = 40, int mother_age = 39) : mother(mother, mother_age), father(father, father_age)
	{
		cout<<"Student(int id, char *father, char *mother, int father_age = 40, int mother_age = 39)"<<endl;
	}

	~Student()
	{
		cout<<"~Student()"<<endl;
	}

	
};

int main(int argc, char **argv)
{
	Student s(100, "bill", "lily");
	
	return 0;
}

程序分析：一个类（Person）中对象作为另外一个类（Student）的成员属性，当实例化这个类（Student）的时候会首先调用被包含类（Person）的构造函数（默认是调用无参构造函数）。并且可以在这个类（Student）的构造函数中给另外一个类（Person）的对象传入参数。。调用析构函数的顺序则相反。

打印结果：

Pserson(char*, int), name = bill, age= 40
Pserson(char*, int), name = lily, age= 39
Student(int id, char *father, char *mother, int father_age = 40, int mother_age = 39)
~Student()
~Person()
name = lily
work = none
~Person()
name = bill
work = none
 

wllen_
关注
C++ 中的几种构造函数
小薇子的博客
11-01 1403
我们对一个对象的操作一般分为下面四种 创建 拷贝 移动 销毁 创建 创建这个操作也就是我们最熟悉的创建一个对象 假设有一个class A： class A{ public: A(int i); A() = default; private: int a_i; }; 我们为它定义了两种构造函数： 含参数的 默认构造函数 因为第一种构造函数只含有一个实参，因为它定义了转换为此类型的隐式转换机制，这种构造函数叫做转换构造函数： A a = 1; 我们可以使用explici
C++中的五种构造函数
qq_41897304的博客
08-02 832
如果形参是一个对象，那么形参的值是否等于实参，取决于该对象所属的类的复制构造函数是如何实现的。例如上面的例子，Func 函数的形参 a 的值在进入函数时是随机的，未必等于实参，因为复制构造函数没有做复制的工作。换言之，作为函数返回值的对象是用复制构造函数初始化 的，而调用复制构造函数时的实参，就是 return 语句所返回的对象。换句话说，作为形参的类A的对象，是用复制构造函数初始化的，而且调用复制构造函数时的参数，就是调用函数时所给的实参。需要注意的是，默认的拷贝构造函数实现的是。这两条语句是等价的。
浅谈C++中的几种构造函数
热门推荐
林多
04-14 3万+
3月中旬参加宣讲会，做了X软公司的C++笔试题，里面有一道“默认拷贝构造函数的题”，由于好久没复习C++基础知识，当时连基本的概念都想不来了了。于是乎，开始拿起以前看的谭浩强C++复习起来，现在书快要要啃完了，觉得收获颇多。好比练武功，秘籍虽然重要，但更重要的还是深厚的内力和扎实的基本功。C++中的构造函数C++中的构造函数可以分为4类： （1）默认构造函数。以Student类为例，默认构造函数的
C++进阶5（构造函数）
henu@wyx南念
06-01 111
构造函数和析构函数 #include <iostream> using namespace std; /*对象的初始化和清理 生活中我们买的电子产品都基本会有出厂设置，在某一天我们不用时候也会删除一些自己信息数据保证安全 C++中的面向对象来源于生活，每个对象也都会有初始设置以及 对象销毁前的清理数据的设置。 构造函数和析构函数 对象的初始化和清理也是两个非常重要的安全问题 ​一个对象或者变量没有初始状态，对其使用后果是未知 ​同样的使用完一个对象或变量，没有及时清理，也会造成一定的安全问
C++（五） 构造函数和析构函数
nowasting4iver的博客
03-20 801
C++（五） 构造函数和析构函数 1. 基本概念 构造函数用于解决对象的初始化。构造函数是一种特殊的成员函数，与其他的函数不同，不需要用户调用，而是在建立对象是自动执行。 1.1 构造函数 C++中类可以定义和类名相同的特殊的成员函数，这种成员函数即构造函数。 注意：构造函数在定义时可以有参数；没有任何返回类型的声明；构造函数可以自动调用（一般情况下C++编译器会自动调用构造函数）或者手动调用（特殊情况）。 1.2 析构函数 理解为构造函数的逆操作。语法为~ClassName() 注意：析构函数没有参数，也
c++学习之构造函数
12-26
#include class Test { private: int i; int j; int k; public : void initialize() { i=0; ... ///构造函数 t1.print(); return 0; } 使用构造函数 #include class Test { private: int i; int
详解C++ 编写String 的构造函数、拷贝构造函数、析构函数和赋值函数
08-29
在C++编程中，正确地管理类的构造函数、拷贝构造函数、析构函数和赋值函数是创建健壮、无内存泄漏程序的关键。接下来将详细介绍如何为自定义的String类编写这些函数，并通过实例来加深理解。 首先，我们定义一个...
完全掌握C++编程中构造函数使用的超级学习教程
01-20
构造函数是一种可初始化其类的实例的成员函数。构造函数具有与类相同的名称，没有返回值。构造函数可以具有任意数量的参数，类可以具有任意数量的重载构造函数。构造函数可以具有任何可访问性（公共、受保护或私有）...
1.5 C++细节五大函数：析构函数，拷贝构造，移动构造，拷贝赋值，移动赋值
wyzeya的博客
11-12 1000
在c++11中，类是和5个特殊的函数紧密相关的，它们是析构函数、拷贝构造函数、移动构造函数、拷贝赋值运算符和移动赋值运算符。 析构函数 只要一个对象运行越出范围，或经受一次delete，则析构函数就要被调用。典型情况下，析构函数的唯一责任就是释放掉在对象使用期间获得的资源，包括关于任意的new操作调用对应的delete，关闭任何打开的文件，等等。默认做法是对每个数据成员应用析构函数。 拷贝构造函数和移动构造函数 有两个特殊的构造函数用来构造一个新的对象，它被初始化为与另一个同样类型对象相同的状态。如
5.构造函数
柳絮飘扬
04-28 198
1.构造函数就是对象的初始化 class complex{ private: double real,imag; public: complex(double r,doublei=0); }; complex::complex(double r,double i){ real=r;imag=i; } complex c1; //error,缺...
[c++] 五种主要函数(构造/赋值重载)的相关行为
ykun089的博客
06-27 693
前言： c++编译器为我们做了很多默认动作，这其中非常重要的一部分就是关于构造函数的。 默认构造函数： 默认构造函数是指 没有参数的构造函数，如果一个构造函数都没有定义，那么编译器会为我们创建默认构造函数，这个构造函数什么都不做。这个由编译器为我们创建的构造函数成为 合成的默认构造函数。 ps：所有由编译器为我们创建的构造函数都叫做 合成的 xxx 构造函数。 拷贝构造函数： 原型：A(const A& a) 拷贝构造函数尽量不要被声明为explicit，因为很多时..
C++5 构造函数
m0_64037754的博客
04-04 579
1构造函数： 初始化对象的数据成员，由编译器自动调用。 ①没有返回值，无void ②函数名与类名相同。 ③自动调用，仅一次。 2析构函数：
五种构造函数与两种懒汉式单例模式 复习
方寸间沧海桑田的博客
10-11 218
1.五种构造函数 class class_test1 { public: class_test1(); class_test1(const class_test1 &a); class_test1(class_test1 &&a)noexcept; class_test1& operator=(const class_test1 &a); clas...
五大函数
Alatebloomer的博客
06-05 1489
类和五个特殊的函数紧密联系在一起，它们分别是析构函数destructor,拷贝构造函数（copy construct，移动构造函数（move constructor）,拷贝赋值函数（copy assignment operator）和移动赋值函数（copy assignment operator）。当类中含有指针作为数据成员时，默认的拷贝以及析构函数会出现问题，必须自己定义。释放自己定义的动态内存...
C++构造函数
More reading and learning to become excellent
01-23 642
// 构造函数(Constructor):构造器,在对象创建的时候自动调用,一般用于完成对象的初始化工作 //特点:函数名与类同名,无返回值(void都n不能写),可以有参数,可以重载,可以有多个构造函数; 一旦定义了构造函数,必须用其中一个自定义的构造函数来初始化对象. 注意:通过malloc分配的对象不会调用构造函数 struct Person { int m_...
c++常引用的应用：使用构造函数做函数参数
lshandel的博客
05-07 860
c++常引用的应用：使用构造函数做函数参数 接触过qt我们知道 qt中一些函数中常常用到类的构造函数作为参数 比如getFont（this，QFont(“黑体”)） 通过这个函数设置字体 其实在平时的编程中我们也可以这么使用，但是函数的定义与声明要使用常引用，下面看一个例子： #include<iostream> using namespace std; class A { private: int a; public: friend void print(const A&amp
【C++】拷贝构造函数调用时机 ② ( 对象值作为函数参数 | 对象值作为函数返回值 )
最新发布
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
09-13 826
一、拷贝构造函数概念 二、对象值作为函数参数 1、拷贝构造函数调用情况说明 2、代码示例 - 对象值作为函数参数 三、对象值作为函数返回值 1、拷贝构造函数调用情况说明 2、代码示例 - 对象值作为函数返回值
c++之构造函数
luoyeliufeng的博客
08-12 280
什么是构造函数 构造函数就是一种函数，他的特点是在对象实例化的时候会自动调用，一般用于数据初始化 规则： 1、构造函数与类同名 2、构造函数没有返回值(所以写构造函数连void都不用写) 3、构造函数可以有多个重载形式(重载就是参数类型不同，个数不同，顺序不同) 4、实例化对象时仅用到一个构造函数 5、如果没定义构造函数，编译器自动生成一个构造函数 Yase.h class Yase { publ...
C++学习：拷贝构造函数详解
"拷贝构造函数-C++学习笔记" 在C++编程中，拷贝构造函数是一种特殊的构造函数，它的主要作用是在创建新对象时，通过已存在的对象来初始化这个新对象。这种机制允许我们复制对象的所有属性和状态，使得新对象与原...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值