这篇文章主要为大家详细介绍了C++的对象特性和友元，使用数据库，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下

对象特征

构造函数和析构函数

对象的初始化和清理也是两个非常重要的安全问题

一个对象或者变量没有初始状态，对其使用后果也是未知

同样的使用完一个对象或变量，没有及时清理，也会造成一定的安全问题 

  • 构造函数：主要作用在于创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，无须手动调用
  • 析构函数：主要作用在于对象销毁前系统自动调用，执行一些清理工作

构造函数语法：类名（）{}

1.构造函数，没有返回值也不写void

2.函数名称与类名相同

3.构造函数可以有参数，因此可以发生重载

4.程序在调用对象时候会自动调用构造，无须手动调用，而且只会调用一次 

析构函数语法：~类名（）{}

1.析构函数，没有返回值也不写void

2.函数名称与类名相同，在名称前加上符号~

3.析构函数不可以有参数，因此不可以发生重载

4.程序在调用对象前会自动调用析构，无须手动调用，而且只会调用一次 

#include<iostream>
using namespace std;
//对象的初始化和清理
//1.构造函数  实现初始化的操作
class Person {
public:
	//1构造函数
	//没有返回值  不用写void
	//函数名 与类名相同
	//构造函数可以有参数，可以发生重载
	//创建对象时，构造函数会自动调用，而且只调用一次
	Person() {
		cout<< "Person构造函数的调用" << endl;
	}
	//2.析构函数  实现清理的操作
	//没有返回值 不写void 
	//函数名和类名相同 在名称前加一个~
	//析构函数不可以有参数，不可以发生重载
	//对象在销毁前 会自动调用析构函数 而且只会调用一次
	~Person() {
		cout << "Person析构函数的调用" << endl;
	}
};
//构造和析构都是必须有的实现，如果我们自己不提供，编译器会提供一个空实现的构造和析构
void test01() {
	Person p;//在栈上的数据，test01执行完毕后，释放这个对象
}
 int main() {
	test01();
	system("pause");
	return 0;
}

函数的分类以及调用

构造函数的分类以及调用

两种分类方式：

  • 按参数分为：有参构造和无参构造
  • 按类型分：普通构造和拷贝构造

三种调用方式：

  • 括号法
  • 显示法
  • 隐式转换法
#include<iostream>
using namespace std;
//构造函数的分类及调用
//分类
//按照参数分类  无参构造（默认构造）和有参构造
//按照类型分类  普通构造 拷贝构造
class Person {
public:
	//构造函数
	Person() {
 		cout << "Person的无参构造函数调用" << endl;
	}
	Person(int a) {
		age = a;
		cout << "Person的有参构造函数调用" << endl;
	}
	//拷贝构造函数
	Person(const Person &p) {
		//将传入的人身上的所有属性，拷贝到“我”身上
		age = p.age;
		cout << "Person的拷贝构造函数调用" << endl;
	}
	~Person() {
		cout << "Person的析构函数调用" << endl;
	}
	int age;
};
//调用
void test01() {
	//1.括号法
	//Person p1;//默认函数调用
	//Person p2(10);//有参构造函数
	//Person p3(p2);//拷贝构造函数
	//注意事项
	//调用默认构造函数的时候，不要加()
	//因为下面这行代码,编译器会认为是一个函数的声明，不会认为在创建对象
	//Person p1();
  	/*cout << "p2的年龄：" << p2.age << endl;
	cout << "p3的年龄：" << p3.age << endl;*/
	//2.显示法
	//Person p1;
	//Person p2 = Person(10);//有参构造
	//Person p3 = Person(p3);//拷贝构造
	//Person(10);//匿名对象 特点：当前行执行结束后，系统会立即回收掉匿名对象
	//
	// 注意事项2
	// 不要利用拷贝构造函数，初始化匿名对象  编译器会认为Person(p3) === Person p3;对象声明
	//Person(p3);
 	//3.隐式转换法
	Person p4 = 10;//相当于 写了 Person p4 = Person(10); 有参构造
	Person p5 = p4;//拷贝构造
}
int main() {
	test01();
	system("pause");
	return 0;
}

拷贝构造函数调用时机

拷贝构造函数调用时机通常有三种情况

1.使用一个已经创建完毕的对象来初始化一个新对象

2.值传递的方式给函数参数传值

3.以值方式返回局部对象

#include<iostream>
using namespace std;
//拷贝构造函数的调用时机
//1.使用一个已经创建完毕的对象来初始化一个新对象
//2.值传递的方式给函数参数传值
//3.值方式返回局部对象
class Person {
public:
	Person() {
		cout << "Person的默认构造函数调用" << endl;
	}
	Person(int age) {
		cout << "Person的有参构造函数调用" << endl;
		m_Age = age;
	}
	Person(const Person &p) {
		cout << "Person的拷贝构造函数调用" << endl;
		m_Age = p.m_Age;
	}
	~Person() {
 		cout << "Person析构函数调用" << endl;
	}
	int m_Age;
};
//拷贝构造函数的调用时机
//1.使用一个已经创建完毕的对象来初始化一个新对象
void test01() {
	Person p1(20);
	Person p2(p1);
	cout << "p2的年龄为：" << p2.m_Age << endl;
}
//2.值传递的方式给函数参数传值
void doWork(Person p) {
  }
 void test02() {
	Person p;
	doWork(p);
}
 //3.值方式返回局部对象
Person doWork2() {
	Person p1;
	return p1;
}
void test03() {
	Person p = doWork2();
}
int main() {	
	//test01();
	//test02();
	test03();
	system("pause");
	return 0;
}

 构造函数调用规则

默认情况下，c++编译器至少给一个类添加3个函数

1.默认构造函数（无参，函数体为空）

2.默认析构函数（无参，函数体为空）

3.默认拷贝构造函数，对属性进行值拷贝

构造函数调用规则如下

如果用户定义有参构造函数，c++不再提供默认无参构造，但是会提供默认拷贝构造

如果用户定义拷贝构造函数，c++不再提供其他构造函数 

#include<iostream>
using namespace std;
//构造函数的调用规则
//1.创建了一个类，c++编译器会给每个类都添加至少三个函数
//默认构造  （空实现）
//析构函数  （空实现）
//拷贝构造  （值拷贝）
//2.如果我们写了有参构造函数，编译器就不再提供默认构造，依然提供拷贝构造
//如果我们写了拷贝构造函数，编译器不再提供其他构造函数了
class Person {
public:
	/*Person() {
		cout << "Person的默认构造函数调用" << endl;
	}*/
	/*Person(int age) {
		cout << "Person的有参构造函数调用" << endl;
		m_Age = age;
	}*/
	Person(const Person& p) {
		cout << "Person的拷贝构造函数调用" << endl;
		m_Age = p.m_Age;
}
 	~Person() {
		cout << "Person的析构函数调用" << endl;
	}
	int m_Age;
};
//void test01() {
//	Person p;
//	p.m_Age = 18;
//	Person p2(p);
//	cout << "p2的年龄为：" << p2.m_Age << endl;
/