【自用19.3】C++构造函数复盘

最新推荐文章于 2024-09-12 21:08:31 发布
最新推荐文章于 2024-09-12 21:08:31 发布
阅读量2k 收藏 41
点赞数 34
分类专栏： C++ 学习笔记 文章标签： c++ 单片机 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_57667919/article/details/142034119
版权

定义一个“人”类

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

using namespace std;

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

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

private:
	string name;
	int age;
	int 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  zhangshan;

	system("pause");
}

对象的使用

.的使用

使用结果

代码

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

using namespace std;

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

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

private:
	string name;
	int age;
	int 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; // 通过自定义的特殊数据类型“Human”类， 来创建一个“对象”

	// 合法使用
	h1.eat();
	h1.play();
	h1.sleep();

	// 非法使用
	//cout << "年龄" << h1.age << endl;  //直接访问私有成员，将无法通过编译

	//正确使用
	cout << "年龄" << h1.getAge() << endl; //暴露问题，年龄值是一个很大的负数

	system("pause");
}

说明：

.符号可以调用public中的成员函数，但是不能访问private中的信息

但是我们可以看到。获取到的年龄是一个负数，这是为什么呢？

->的使用

使用结果

代码如下

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

using namespace std;

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

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

private:
	string name;
	int age;
	int 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; // 通过自定义的特殊数据类型“Human”类， 来创建一个“对象”
	Human* p;

	p = &h1;

	// 合法使用
	p->eat();
	p->play();
	p->sleep();

	// 非法使用
	//cout << "年龄" << p->age << endl;  //直接访问私有成员，将无法通过编译

	//正确使用
	cout << "年龄" << p->getAge() << endl; //暴露问题，年龄值是一个很大的负数

	system("pause");
}

 在主函数中

首先自定义一个Human类类型的对象h1

然后定义一个Human类类型的指针

将h1的地址赋值给这个指针，相当于这个指针指向了h1这个对象

注意：Human是类名，Human是一个类，类中定义的叫做对象，比如h1。所以h1叫做Human类型的对象。

然后使用指针和->符号调用h1的成员函数。

最后调用的结果和第一种使用方式的结果是非常类似的。

但是我们可以知道，不同的对象，参数肯定也是不一样，那我们怎么去给不同的对象附上不同的参数呢？

构造函数

作用：

创建新的对象时，自动调用构造函数来进行初始化工作，这个初始化工作的内容是对对象内部的数据成员进行初始化。

特点：

  1. 自动调用（在创建新对象时，自动调用）
  2. 构造函数的函数名，和类名相同
  3. 构造函数没有返回类型
  4. 可以有多个构造函数（即函数重载形式）

种类：

默认构造函数

自定义的构造函数

拷贝构造函数

赋值构造函数

默认构造函数

没有参数的构造函数，称为默认构造函数

分类

合成的默认构造函数

手动定义的默认构造函数

合成的默认构造函数

 使用结果

代码

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

using namespace std;

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

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

private:
	string name;
	int age = 18;
	int 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;  // 使用合成的默认初始化构造函数
	cout << "年龄: " << h1.getAge() << endl;     //使用了类内初始值
	cout << "薪资：" << h1.getSalary() << endl;  //没有类内初始值

	system("pause");
	return 0;
}

 在上面这段代码中，在定义人类的使用，在private的年龄变量中初始化为了18。

后期没有手动编写构造函数，所以合成的默认构造函数使用了原本初始化的值，没有初始化的变量被赋给了一个很大的负数。

注意：

只要手动定义了任何一个构造函数，编译器就不会生成“合成的默认构造函数”

一般情况下，都应该定义自己的构造函数，不要使用“合成的默认构造函数”

【仅当数据成员全部使用了“类内初始值”，才宜使用“合成的默认构造函数”】

手动定义的默认构造函数

 使用结果

代码

#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;
	int age = 18;
	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;
}

 手动定义的默认构造函数简称默认构造函数

手动定义默认构造函数的话，需要在定义类的时候在public中声明这个默认构造函数，否则会出现问题。

根据代码的运行结果我们可以知道，如果某数据成员使用类内初始值，同时又在构造函数中进行了初始化，那么以构造函数中的初始化为准。相当于构造函数中的初始化，会覆盖对应的类内初始值。

 自定义的重载构造函数

使用结果

代码

#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;
	int age = 18;
	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;
}

 自定义的重载构造函数需要在定义类时，在public中进行函数重载的声明。

重载的函数与自定义的构造函数不同，重载的构造函数可以有传入的信息值，自定义的默认构造函数是没有参数的，因为默认构造的特点是没有参数。

在这里编写的自定义构造函数传入两个参数，年龄和工资，根据运行结果可以知道，当自定义的构造函数中信息的值与默认构造函数或者定义中的信息冲突的时候，要以自定义构造函数中传入的值为准。

拷贝构造函数

手动定义的拷贝构造函数 

使用结果

 

代码

#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;
	int age = 18;
	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 << "姓名：" << h1.getName() << endl;
	cout << "年龄: " << h1.getAge() << endl;
	cout << "薪资：" << h1.getSalary() << endl;

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


	system("pause");
	return 0;
}

 手动定义的拷贝函数函数的参数是一个对象，并且需要在类定义中的public中进行声明

使用拷贝构造函数之后，创建的新的对象的信息与所拷贝的对象的信息相同

合成的拷贝构造函数

使用结果

 

代码

#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;
	int age = 18;
	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;
}

 不定义拷贝构造函数的话，编译器会自动生成合成拷贝构造函数

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

根据运行结果来看，由于h2拷贝了h1的信息。所以修改h1的信息的时候，h2的信息也会跟着改变。

但是需要注意的是两个对象的指针却是不一样的

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

使用结果

代码

#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;
	int age = 18;
	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;

	cout << "h1" << &h1 << endl;
	cout << "h2" << &h2 << endl;


	system("pause");
	return 0;
}

 “深拷贝”中，自定义的拷贝构造函数直接将所拷贝的对象h1的信息赋给新定义的对象h2，这样操作之后，被拷贝的对象h1的信息修改的时候，拷贝得到的对象h2的信息不会被修改。

那么

什么时候使用拷贝构造函数呢？

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;
	int age = 18;
	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;
}

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;
	int age = 18;
	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);
}

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, 64, man.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;
}

 综合来看，如果是创建对象并初始化，则调用拷贝构造函数，如果是直接赋值，则使用赋值构造函数。

以上构造函数的复盘结束~

.远_
关注
  • 34
    点赞
  • 踩
  • 41
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C/C++基础(自用)-04
sinat_41570350的博客
10-12 311
C/C++基础(自用)-04
C++ ： 构造函数，拷贝构造函数,移动构造函数，拷贝赋值运算符，移动赋值运算符应用场景
superSmart_Dong的博客
08-24 1194
#include <iostream> using namespace std; class ConstructTest{ public: ConstructTest(){ cout<<"default Constructor\n"; }; ~ConstructTest(){ cout<<"Destructor"<<endl; } ConstructTest(int...
c++ sort函数cmp比较参数传入
kunlewang的博客
10-13 611
自用
自用复习C++
wuersd的博客
01-02 985
X 1．声明一个引用后，可以为该引用指定不同的引用对象。√ 2．类可以定义多个构造函数，但只能有一个复制构造函数和一个析构函数。X 3．若A类是B类的友元类，则B类的所有成员函数都可访问A类成员。X 4．派生类能够继承基类中的友元函数。√ 5．虚基类定义中关键字virtual只对其后的基类有效。√ 6. 重载的运算符不可改变其原来的优先级和结合性。X 7. 抽象类的派生类一定是非抽象类。√ 8. 类模板的使用是首先将其实例化成一个模板类，再实例化对象。
C++笔记（自用）
dirkmswei的博客
12-05 1212
C++基础语法，提高编程，STL技术，Effective C++
基于 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++23种设计模式概述】
m0_45463480的博客
09-09 680
c++23种设计模式概述。
C语言 | Leetcode C语言题解之第389题找不同
m0_59237910的博客
09-07 694
C语言 | Leetcode C语言题解之第389题找不同
C语言初阶 --- ⾃定义类型：结构体
2301_79842589的博客
09-08 980
💫往期文章👇：
C语言——strcpy、sprintf与memcpy
鲸落博客
09-09 1096
该函数和printf()函数有很多相似之处，例如printf()将不同类型的数据格式化到终端，而sprintf()函数是将不同类型的数据格式化到字符串中。另外，和strcpy()函数一样，该函数也不会对目标缓冲区进行检查，容易造成溢出。它是一种非常通用的内存复制函数，不仅限于复制字符串，还可以复制任何类型的内存块。3. 未定义行为：程序可能会继续运行，但结果不可预测，可能会输出错误的结果或导致其他未预料的行为。如果memcpy复制字符串，要复制的字节数超过原内存块本身的内存数，会怎么样？
C语言作用域
天道酬勤
09-07 994
作用域 (scope) 是描述程序可以访问标识符的区域。块是一对花括号 {} 括起来的区域 或 函数体内任意复合语句定义范围内的区域。定义在块中的变量具有块作用域。块作用域的变量的可见范围从定义处开始到该块定义范围的末尾为止。函数作用域是在整个函数体内可见的意思，在 C 程序中，函数形参和 goto 语句的标签具有函数作用域，在整个函数体内可见。在所有函数外定义的变量具有全局作用域，在整个程序都可见。在数据类型前加 static 关键字定义的全局变量具有文件作用域。
c++ 类的继承详解
HJQD777的博客
09-07 501
继承允许类之间建立层次关系，促进代码重用和扩展。继承有不同的访问控制方式（publicprotectedprivate），影响派生类对基类成员的访问权限。基类的构造函数和析构函数不会被继承，派生类需要自行定义。使用虚函数和多态可以实现灵活的接口设计和动态方法调用。理解继承机制对于设计高效、灵活和可维护的面向对象系统至关重要。
C++ #include ＜cstring＞（详解）
qq_51753728的博客
09-08 991
是在 C++ 程序中引入头文件<cstring>的语句。这个头文件提供了用于处理 C 风格字符串（即以空字符'\0'结尾的字符数组）的函数。具体来说，<cstring>（1）strcpystrcpy是cstring中用于复制 C 风格字符串的函数，它将源字符串的内容复制到目标字符串中，包括末尾的空字符 ('\0'使用strcpy时需要确保目标数组有足够的空间来存放源字符串。source。
C++ 中 vector 的常用功能介绍
最新发布
2202_75569688的博客
09-12 316
在 C++ 中，vector是一种常用的动态数组容器，提供了方便的自动扩展、内存管理以及各种便捷的操作方法。它是 C++ 标准模板库（STL）的一部分，适用于需要动态存储和管理大量元素的场景。在本文中，我们将简要介绍vector的常用功能，展示如何对其进行操作和排序。为了简洁起见，假设我们已经使用了。
STL经典案例（四）——实验室预约综合管理系统（项目涉及知识点很全面，内容有点多，耐心看完会有收获的！）
beyond谚语的博客
09-08 423
高校实验室预约管理系统 管理员：创建实验室教师账号、学生账号、实验室；查看实验室教师、学校、实验室信息；清空所有学生的预约记录 学生：申请实验室预约、查看所有实验室预约 实验室教师：审核学生的申请、查看所有学生的实验室申请预约
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值