【自用19.2】C++构造函数

于 2024-09-03 20:45:06 发布
阅读量259 收藏 1
点赞数 8
分类专栏： 学习笔记 C++ 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_57667919/article/details/141871287
版权

手动定义的默认构造函数

常称为“默认构造函数”

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

using namespace std;

// 定义一个“人类”
class Human {
public:  //公有的，对外的
	Human(); //手动定义的“默认构造函数”
	void eat(); //方法， “成员函数”
	void sleep();
	void play();
	void work();

	string getName();
	int getAge();
	int getSalary();

private:
	string name = "Unknown";
	int age = 28;
	int salary;
};

Human::Human() {
	name = "无名氏";
	age = 18;
	salary = 30000;
}

void Human::eat() {
	cout << "吃炸鸡，喝啤酒！" << endl;
}

void Human::sleep() {
	cout << "我正在睡觉!" << endl;
}

void Human::play() {
	cout << "我在唱歌! " << endl;
}

void Human::work() {
	cout << "我在工作..." << endl;
}

string Human::getName() {
	return name;
}

int Human::getAge() {
	return age;
}

int Human::getSalary() {
	return salary;
}


int main(void) {
	Human  h1;  // 使用自定义的默认构造函数
	cout << "姓名：" << h1.getName() << endl;
	cout << "年龄: " << h1.getAge() << endl;    
	cout << "薪资：" << h1.getSalary() << endl; 

	system("pause");
	return 0;
}

说明：如果某数据成员使用类内初始值，同时又在构造函数中进行了初始化，

      那么以构造函数中的初始化为准。

      相当于构造函数中的初始化，会覆盖对应的类内初始值。

自定义的重载构造函数

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

using namespace std;

// 定义一个“人类”
class Human {
public:  
	Human();
	Human(int age, int salary);

	void eat(); 
	void sleep();
	void play();
	void work();

	string getName();
	int getAge();
	int getSalary();

private:
	string name = "Unknown";
	int age = 28;
	int salary;
};

Human::Human() {
	name = "无名氏";
	age = 18;
	salary = 30000;
}

Human::Human(int age, int salary) {
	cout << "调用自定义的构造函数" << endl; 
	this->age = age;      //this是一个特殊的指针，指向这个对象本身
	this->salary = salary;
	name = "无名";
}


void Human::eat() {
	cout << "吃炸鸡，喝啤酒！" << endl;
}

void Human::sleep() {
	cout << "我正在睡觉!" << endl;
}

void Human::play() {
	cout << "我在唱歌! " << endl;
}

void Human::work() {
	cout << "我在工作..." << endl;
}

string Human::getName() {
	return name;
}

int Human::getAge() {
	return age;
}

int Human::getSalary() {
	return salary;
}


int main(void) {
	Human  h1(25, 35000);  // 使用自定义的默认构造函数

	cout << "姓名：" << h1.getName() << endl;
	cout << "年龄: " << h1.getAge() << endl;    
	cout << "薪资：" << h1.getSalary() << endl; 

	system("pause");
	return 0;
}

拷贝构造函数

 手动定义的拷贝构造函数

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

using namespace std;

// 定义一个“人类”
class Human {
public:  
	Human();
	Human(int age, int salary);
	Human(const Human&);

	void eat(); 
	void sleep();
	void play();
	void work();

	string getName();
	int getAge();
	int getSalary();

private:
	string name = "Unknown";
	int age = 28;
	int salary;
};

Human::Human() {
	name = "无名氏";
	age = 18;
	salary = 30000;
}

Human::Human(int age, int salary) {
	cout << "调用自定义的构造函数" << endl; 
	this->age = age;      //this是一个特殊的指针，指向这个对象本身
	this->salary = salary;
	name = "无名";
}

Human::Human(const Human& man) {
	cout << "调用自定义的拷贝构造函数" << endl;
	name = man.name;
	age = man.age;
	salary = man.salary;
}


void Human::eat() {
	cout << "吃炸鸡，喝啤酒！" << endl;
}

void Human::sleep() {
	cout << "我正在睡觉!" << endl;
}

void Human::play() {
	cout << "我在唱歌! " << endl;
}

void Human::work() {
	cout << "我在工作..." << endl;
}

string Human::getName() {
	return name;
}

int Human::getAge() {
	return age;
}

int Human::getSalary() {
	return salary;
}


int main(void) {
	Human  h1(25, 35000);  // 使用自定义的默认构造函数
	Human  h2(h1);  // 使用自定义的拷贝构造函数

	cout << "姓名：" << h2.getName() << endl;
	cout << "年龄: " << h2.getAge() << endl;    
	cout << "薪资：" << h2.getSalary() << endl; 

	system("pause");
	return 0;
}

 合成的拷贝构造函数

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

using namespace std;

// 定义一个“人类”
class Human {
public:  
	Human();
	Human(int age, int salary);
	//Human(const Human&);  //不定义拷贝构造函数，编译器会生成“合成的拷贝构造函数”

	void eat(); 
	void sleep();
	void play();
	void work();

	string getName();
	int getAge();
	int getSalary();
	void setAddr(const char *newAddr);
	const char* getAddr();

private:
	string name = "Unknown";
	int age = 28;
	int salary;
	char *addr;
};

Human::Human() {
	name = "无名氏";
	age = 18;
	salary = 30000;
}

Human::Human(int age, int salary) {
	cout << "调用自定义的构造函数" << endl; 
	this->age = age;      //this是一个特殊的指针，指向这个对象本身
	this->salary = salary;
	name = "无名";

	addr = new char[64];
	strcpy_s(addr, 64, "China");
}

void Human::eat() {
	cout << "吃炸鸡，喝啤酒！" << endl;
}

void Human::sleep() {
	cout << "我正在睡觉!" << endl;
}

void Human::play() {
	cout << "我在唱歌! " << endl;
}

void Human::work() {
	cout << "我在工作..." << endl;
}

string Human::getName() {
	return name;
}

int Human::getAge() {
	return age;
}

int Human::getSalary() {
	return salary;
}

void Human::setAddr(const char *newAddr) {
	if (!newAddr) {
		return; 
	}

	strcpy_s(addr, 64,  newAddr);
}

const char* Human::getAddr() {
	return addr;
}





int main(void) {
	Human  h1(25, 35000);  // 使用自定义的默认构造函数
	Human  h2(h1);  // 使用自定义的拷贝构造函数

	cout << "h1 addr:" << h1.getAddr() << endl;
	cout << "h2 addr:" << h2.getAddr() << endl;
	
	h1.setAddr("长沙");

	cout << "h1 addr:" << h1.getAddr() << endl;
	cout << "h2 addr:" << h2.getAddr() << endl;

	system("pause");
	return 0;
}

说明：

合成的拷贝构造函数的缺点: 使用“浅拷贝”

解决方案：在自定义的拷贝构造函数中，使用‘深拷贝

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

using namespace std;

// 定义一个“人类”
class Human {
public:
	Human();
	Human(int age, int salary);
	Human(const Human&);  //不定义拷贝构造函数，编译器会生成“合成的拷贝构造函数”

	void eat();
	void sleep();
	void play();
	void work();

	string getName();
	int getAge();
	int getSalary();
	void setAddr(const char *newAddr);
	const char* getAddr();

private:
	string name = "Unknown";
	int age = 28;
	int salary;
	char *addr;
};

Human::Human() {
	name = "无名氏";
	age = 18;
	salary = 30000;
}

Human::Human(int age, int salary) {
	cout << "调用自定义的构造函数" << endl;
	this->age = age;      //this是一个特殊的指针，指向这个对象本身
	this->salary = salary;
	name = "无名";

	addr = new char[64];
	strcpy_s(addr, 64, "China");
}

Human::Human(const Human &man) {
	cout << "调用自定义的拷贝构造函数" << endl;
	age = man.age;      //this是一个特殊的指针，指向这个对象本身
	salary = man.salary;
	name = man.name;
	// 深度拷贝
	addr = new char[64];
	strcpy_s(addr, 64, man.addr);
}

void Human::eat() {
	cout << "吃炸鸡，喝啤酒！" << endl;
}

void Human::sleep() {
	cout << "我正在睡觉!" << endl;
}

void Human::play() {
	cout << "我在唱歌! " << endl;
}

void Human::work() {
	cout << "我在工作..." << endl;
}

string Human::getName() {
	return name;
}

int Human::getAge() {
	return age;
}

int Human::getSalary() {
	return salary;
}

void Human::setAddr(const char *newAddr) {
	if (!newAddr) {
		return;
	}

	strcpy_s(addr, 64, newAddr);
}

const char* Human::getAddr() {
	return addr;
}

int main(void) {
	Human  h1(25, 35000);  // 使用自定义的默认构造函数
	Human  h2(h1);  // 使用自定义的拷贝构造函数

	cout << "h1 addr:" << h1.getAddr() << endl;
	cout << "h2 addr:" << h2.getAddr() << endl;

	h1.setAddr("长沙");

	cout << "h1 addr:" << h1.getAddr() << endl;
	cout << "h2 addr:" << h2.getAddr() << endl;

	system("pause");
	return 0;
}

什么时候调用拷贝构造函数

1.调用函数时，实参是对象，形参不是引用类型

   如果函数的形参是引用类型，就不会调用拷贝构造函数

2.函数的返回类型是类，而且不是引用类型

3.对象数组的初始化列表中，使用对象。

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

using namespace std;

// 定义一个“人类”
class Human {
public:
	Human();
	Human(int age, int salary);
	Human(const Human&);  //不定义拷贝构造函数，编译器会生成“合成的拷贝构造函数”

	void eat();
	void sleep();
	void play();
	void work();

	string getName();
	int getAge();
	int getSalary();
	void setAddr(const char *newAddr);
	const char* getAddr();

private:
	string name = "Unknown";
	int age = 28;
	int salary;
	char *addr;
};

Human::Human() {
	name = "无名氏";
	age = 18;
	salary = 30000;
}

Human::Human(int age, int salary) {
	cout << "调用自定义的构造函数" << endl;
	this->age = age;      //this是一个特殊的指针，指向这个对象本身
	this->salary = salary;
	name = "无名";

	addr = new char[64];
	strcpy_s(addr, 64, "China");
}

Human::Human(const Human &man) {
	cout << "调用自定义的拷贝构造函数" << "参数：" << &man
		 << " 本对象：" << this << endl;

	age = man.age;      //this是一个特殊的指针，指向这个对象本身
	salary = man.salary;
	name = man.name;
	// 深度拷贝
	addr = new char[64];
	strcpy_s(addr, 64, man.addr);
}

void Human::eat() {
	cout << "吃炸鸡，喝啤酒！" << endl;
}

void Human::sleep() {
	cout << "我正在睡觉!" << endl;
}

void Human::play() {
	cout << "我在唱歌! " << endl;
}

void Human::work() {
	cout << "我在工作..." << endl;
}

string Human::getName() {
	return name;
}

int Human::getAge() {
	return age;
}

int Human::getSalary() {
	return salary;
}

void Human::setAddr(const char *newAddr) {
	if (!newAddr) {
		return;
	}

	strcpy_s(addr, 64, newAddr);
}

const char* Human::getAddr() {
	return addr;
}


void test(Human man) {
	cout << man.getSalary() << endl;
}

void test2(Human &man) { //不会调用拷贝构造函数，此时没有没有构造新的对象
	cout << man.getSalary() << endl;
}

Human test3(Human &man) {
	return man;
}

Human& test4(Human &man) {
	return man;
}


int main(void) {
	Human h1(25, 35000);  // 调用默认构造函数
	Human h2(h1);         // 调用拷贝构造函数
	Human h3 = h1;		  // 调用拷贝构造函数

	test(h1);		      // 调用拷贝构造函数
	test2(h1);			  // 不会调用拷贝构造函数
	test3(h1);            // 创建一个临时对象，接收test3函数的返回值，调用1次拷贝构造函数
	Human h4 = test3(h1); // 仅调用1次拷贝构造函数，返回的值直接作为h4的拷贝构造函数的参数
	test4(h1);            // 因为返回的是引用类型，所以不会创建临时对象，不会调用拷贝构造函数
	
	Human men[] = { h1, h2, h3 }; //调用3次拷贝构造函数

	system("pause");
	return 0;
}

赋值构造函数

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

using namespace std;

// 定义一个“人类”
class Human {
public:
	Human();
	Human(int age, int salary);
	Human(const Human&);  //不定义拷贝构造函数，编译器会生成“合成的拷贝构造函数”
	Human& operator=(const Human &);

	void eat();
	void sleep();
	void play();
	void work();

	string getName();
	int getAge();
	int getSalary();
	void setAddr(const char *newAddr);
	const char* getAddr();

private:
	string name = "Unknown";
	int age = 28;
	int salary;
	char *addr;
};

Human::Human() {
	name = "无名氏";
	age = 18;
	salary = 30000;
}

Human::Human(int age, int salary) {
	cout << "调用自定义的构造函数" << endl;
	this->age = age;      //this是一个特殊的指针，指向这个对象本身
	this->salary = salary;
	name = "无名";

	addr = new char[64];
	strcpy_s(addr, 64, "China");
}

Human::Human(const Human &man) {
	cout << "调用自定义的拷贝构造函数" << "参数：" << &man
		 << " 本对象：" << this << endl;

	age = man.age;      //this是一个特殊的指针，指向这个对象本身
	salary = man.salary;
	name = man.name;
	// 深度拷贝
	addr = new char[64];
	strcpy_s(addr, 64, man.addr);
}


Human& Human::operator=(const Human &man) {
	cout << "调用" << __FUNCTION__ << endl;
	if (this == &man) {
		return *this; //检测是不是对自己赋值：比如 h1 = h1;
	}

	// 如果有必要，需要先释放自己的资源（动态内存）
	//delete addr;
	//addr = new char[ADDR_LEN];

	// 深拷贝
	strcpy_s(addr, ADDR_LEN, other.addr);

	// 处理其他数据成员
	name = man.name;
	age = man.age;
	salary = man.salary;

	// 返回该对象本身的引用， 以便做链式连续处理，比如 a = b = c;
	return *this;
}


void Human::eat() {
	cout << "吃炸鸡，喝啤酒！" << endl;
}

void Human::sleep() {
	cout << "我正在睡觉!" << endl;
}

void Human::play() {
	cout << "我在唱歌! " << endl;
}

void Human::work() {
	cout << "我在工作..." << endl;
}

string Human::getName() {
	return name;
}

int Human::getAge() {
	return age;
}

int Human::getSalary() {
	return salary;
}

void Human::setAddr(const char *newAddr) {
	if (!newAddr) {
		return;
	}

	strcpy_s(addr, 64, newAddr);
}

const char* Human::getAddr() {
	return addr;
}


void test(Human man) {
	cout << man.getSalary() << endl;
}

void test2(Human &man) { //不会调用拷贝构造函数，此时没有没有构造新的对象
	cout << man.getSalary() << endl;
}

Human test3(Human &man) {
	return man;
}

Human& test4(Human &man) {
	return man;
}


int main(void) {
	Human h1(25, 35000);  // 调用默认构造函数

      // 特别注意，此时是创建对象h2并进行初始化，调用的是拷贝构造函数，
	// 不会调用赋值构造函数
	Human h2 = h1;  

	h2 = h1; //调用赋值构造函数
	h2 = test3(h1); //调用赋值构造函数

	Human h3 = test3(h1); //调用拷贝构造函数

	system("pause");
	return 0;
}

如果没有定义赋值构造函数，编译器会自动定义“合成的赋值构造函数”，

与其他合成的构造函数，是“浅拷贝”（又称为“位拷贝”）。

.远_
关注
  • 8
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
构造函数
熊俊坤的博客
03-09 784
前言C++的目标之一就是让用户使用类对象就像使用基本内置类型对象一样。
java中的构造函数
weixin_44263279的博客
01-13 221
构造函数 构造函数是一种特殊的方法，主要用来在创建对象时对其进行初始化，即为对象成员变量赋初始值，总与new运算符一起使用在创建对象的语句中。 一个类可以有多个构造函数，可根据其参数个数或参数的类型不同来区分它们，即构造函数的重载 方法名称和类名称一致，包括大小写 没有返回值类型的声明 在一个类中允许方法同名（方法重载），要求参数不同：类型、个数、顺序 构造器方法不能直接调用，只能通过new运算符间接调用 public class B1{ public B1(){} public B1(
【JS小知识】this的指向、工厂方法、构造函数及优化、prototype原型、forEach()的使用
因为遇见你，我，三生有幸呀
01-28 854
/** * 解析器在调用函数时，每次都会向函数内部传递一个隐含的参数 * 这个隐含的参数就是this，this指向的是一个对象， * 这个对象我们称为函数执行的上下文对象， * 根据函数的调用方式的不同，this会指向不同的对象 * 1、以函数方式调用，this是window * 2、以方法的形式调用时，this就是调用方法的那个对象 * 3、以构造函数的形式调用时，this是新创建的对象 * */ function...
基于 log4cplus 封装的自用的 C++ 日志库.zip
06-03
C++是一种广泛使用的编程语言，它是由Bjarne Stroustrup于1979年在新泽西州美利山贝尔实验室开始设计开发的。C++是C语言的扩展，旨在提供更强大的编程能力，包括面向对象编程和泛型编程的支持。C++支持数据...
自用的c++学习框架，便于学习一些基础知识和各种库的使用。.zip
最新发布
06-05
C++是一种面向对象的...虚函数（virtual function）、运算符重载（Operator Overloading）、多重继承（Multiple Inheritance）、模板（Template）、异常（Exception）、RTTI、命名空间（Name Space）逐渐被加入标准。
推荐自用 Javascript 缩图函数 (onDOMLoaded)……
10-30
在本篇文章中，我们将讨论一个推荐的 JavaScript 缩图函数，特别关注其在 DOM（文档对象模型）加载完成但图片尚未加载时的处理方式，以及如何实现跨浏览器兼容性。这个函数被称为 onDOMLoaded，并结合了一个缩图功能...
MFC-20130617_MFC自用_pk函数parasolid_
10-02
在这个主题中，"MFC-20130617_MFC自用_pk函数parasolid_"，我们主要关注的是与MFC相关的自定义函数以及可能涉及到的Parasolid库的使用。 首先，"MFC自用"暗示了这是一些个人或团队在开发过程中经常使用的MFC扩展...
C/C++基础(自用)-04
sinat_41570350的博客
10-12 309
C/C++基础(自用)-04
自用代码资源：设备状态枚举定义
"该资源是一个自用的代码片段，用于定义设备的不同状态，主要涉及到通话和充电等场景。" 在给定的代码中，我们看到一个条件编译块`#ifdef __BT_ONE_BRING_TWO__`，这通常用于区分不同的编译配置或针对特定平台的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值