C/C++ 类与构造析构等知识

简单定义类

#include <iostream>
#include <string>

using namespace std;

class Student
{
public:
	int uid;
	char *name;
	int age;

public:
	void set(int id, char *name, int age)
	{
		this->uid = id;
		this->name = name;
		this->age = age;
	}
	void display()
	{
		cout << this->uid << this->name << this->age << endl;
	}
};

void Call(const Student &ptr)
{
	cout << ptr.name << endl;
}

int main(int argc, char *argv[])
{
	Student stu;   // 实例化

	stu.set(1001, "lyshark", 23);                     // 设置数据
	cout << stu.uid << stu.name << stu.age << endl;   // 输出
	stu.display();                                    // 使用成员函数输出

	Student *ptr = &stu;           // 使用指针
	cout << ptr->uid << ptr->name << ptr->age << endl;

	Call(stu);
	system("pause");
	return 0;
}

构造/析构 函数: 构造函数与类名相同，没有返回值，不写void，可以发生重载，可以有参数

#include <iostream>
#include <string>

using namespace std;

class Student
{
public:
	int uid;
	char *name;
	int age;

public:
	Student(int uid,char *name,int age)     // 构造函数
	{
		this->uid = uid;
		this->name = name;
		this->age = age;
	}
	~Student()                              // 析构函数
	{
		cout << "执行结束,析构 !" << endl;
	}
	void Display()
	{
		cout << this->name << endl;
	}

};

int main(int argc, char *argv[])
{
	
	class Student *stu_ptr[3];

	Student stu1(1001, "admin", 22);
	Student stu2(1002, "guest", 33);
	Student stu3(1003, "tudyit", 25);

	stu_ptr[0] = &stu1;
	stu_ptr[1] = &stu2;
	stu_ptr[2] = &stu3;

	for (int x = 0; x < 3; x++)
		stu_ptr[x]->Display();

	system("pause");
	return 0;
}

析构函数，没有返回值，不可以写参数，不能发生重载，多用于最后的类的清理左右。

无参数构造函数（默认构造函数），有参数

拷贝构造函数:

#include <iostream>
#include <string>

using namespace std;

class Student
{
public:
	int uid;
	char *name;
	int age;

public:
	Student(int uid,char *name,int age)     // 构造函数
	{
		this->uid = uid;
		this->name = name;
		this->age = age;
	}
	Student(const Student& ptr)             // 拷贝构造函数
	{
		name = ptr.name;                    // 将 拷贝参数赋值给被拷贝类中
		cout << "kaobei" << endl;
	}
};

int main(int argc, char *argv[])
{
	Student stu1(1001, "admin", 22);
	
	// 拷贝构造函数：括号法调用
	// 调用拷贝构造函数 stu1 拷贝到stu2中
	Student stu2(stu1);
	cout << stu2.name << endl;

	Student stu3 = Student(stu1);
	cout << stu3.name << endl;

	system("pause");
	return 0;
}

浅拷被： 容易崩溃，系统简单的传值，出现问题。

#include <iostream>
#include <string>

using namespace std;

class Student
{
public:
	char * m_name;
	int m_age;

public:
	Student()
	{

	}
	Student(char * name, int age)
	{
		m_name = (char *)malloc(strlen(name) + 1);
		strcpy(m_name, name);
	}
	~Student()
	{
		if (m_name != NULL)
			free(m_name);
	}

};


int main(int argc, char *argv[])
{
	Student stu1("lyshark",25);
	// < 浅拷贝,出现了崩溃的问题> 因为执行了两次析构，出现了冲突
	Student stu2(stu1);            // 调用拷贝构造函数

	system("pause");
	return 0;
}

深拷贝： 自己开辟堆空间，然后自己在拷贝构造函数中拷贝数据，防止冲突，同样的代码不会出现问题了。

#include <iostream>
#include <string>

using namespace std;

class Student
{
public:
	char * m_name;
	int m_age;

public:
	Student()
	{

	}
	Student(char * name, int age)
	{
		m_name = (char *)malloc(strlen(name) + 1);
		strcpy(m_name, name);
	}
	~Student()
	{
		if (m_name != NULL)
			free(m_name);
	}
	Student(const Student &ptr)
	{
		m_age = ptr.m_age;
		m_name = (char *)malloc(strlen(ptr.m_name) + 1);
		strcpy(m_name, ptr.m_name);     // 深层拷贝
	}
};

int main(int argc, char *argv[])
{
	Student stu1("lyshark",25);
	// < 浅拷贝,出现了崩溃的问题> 因为执行了两次析构，出现了冲突
	Student stu2(stu1);            // 调用拷贝构造函数

	system("pause");
	return 0;
}

多个对象的构造和析构：初始化列表

#include <iostream>
#include <string>

using namespace std;

class Student
{
public:
	char * m_name;
	int m_age;

public:
	Student(char * x, int y) :m_name(x), m_age(y){}
};


int main(int argc, char *argv[])
{
	Student stu("lyshark",23);
	cout << stu.m_name << stu.m_age << endl;


	system("pause");
	return 0;
}

explicit 关键字的作用 该关键字为了防止隐世类型转换,就是防止你瞎搞。

#include <iostream>
#include <string>

using namespace std;

class MyString
{
public:
	char * m_Str;

public:
	MyString(const char *str)
	{

	}
	// 该关键字为了防止隐世类型转换
	explicit MyString(int num)
	{

	}

};


int main(int argc, char *argv[])
{
	MyString str = "lyshark";    // 显示调用

	// MyString str2 = 10;

	system("pause");
	return 0;
}

new 动态对象创建: 忘记 malloc() /free 吧，new 可以自动分配初始化空间，非常方便。开辟空间到堆。

#include <iostream>
#include <string>

using namespace std;

class Student
{
public:
	char * m_Str;

public:
	Student()
	{
		cout << "默认构造调用" << endl;
	}
	~Student()
	{
		cout << "默认析构调用" << endl;
	}
};


int main(int argc, char *argv[])
{
	// Student stu1;        // 在站区开辟空间

	// 所有new出来的对象都会返回该类型的指针
	// malloc 返回 void* 还必须要强转
	// new 会调用构造函数? new 并不是函数而是运算符

	Student *stu2 = new Student;   // 堆区开辟空间
	// 释放堆空间
	delete stu2;

	// new 来开辟数组 , 他一定会调用默认构造函数，有多少数组成员就调用多少次！
	Student *pArray = new Student[10];

	pArray[0].m_Str = "lyshark";

	cout << pArray[0].m_Str << endl;

	// 释放整个数组,必须加[] 中括号
	delete [] pArray;


	system("pause");
	return 0;
}

静态成员变量: static声明就是静态成员变量，无论建立多少对象，都只有一个静态数据的拷贝，所有对象都共享这个静态数据。

#include <iostream>

using namespace std;

class Student
{
public:
	// 静态成员变量,在类内声明，在类外初始化
	static int m_number;  // 定义静态变量
};

int Student::m_number = 100;      // 类外初始化实现

int main(int argc, char *argv[])
{
	Student stu1, stu2;
	
	stu1.m_number = 200;  // stu1赋值后,会影响stu2里面的,两个是共享数据的

	cout << stu1.m_number << endl;
	cout << stu2.m_number << endl;
	cout << "通过类名直接访问:"<< Student::m_number << endl;

	system("pause");
	return 0;
}

静态成员函数:

#include <iostream>

using namespace std;

class Student
{
public:
	static void Display()
	{
		cout << "hello lyshark" << endl;
	}
};


int main(int argc, char *argv[])
{
	Student stu1,stu2;

	// 静态成员函数,不可以访问普通成员变量
	// 但是可以访问静态成员变量

	stu1.Display();     // 两个对象同样是调用的一个函数。
	stu2.Display();

	system("pause");
	return 0;
}

单例模式设计思想： 一个类中，是能实例化出一个对象，这样就可以防止冲突的情况发生。

想想，如何实现，不论new多少次，始终只能保证，创建一个对象，不多创建。

#include <iostream>

using namespace std;

// 创建列中的对象，并且保证只有一个对象可以使用，一个对象实例。

class ChairMan
{
private:
	// 1.将构造函数自由化，改成private
	// 
	ChairMan(){ cout << "create super" << endl; }
public:
	static ChairMan *singleMan;

};

ChairMan * ChairMan::singleMan = new ChairMan;

int main(int argc, char *argv[])
{
	cout << "main" << endl;  // 主席创建，先于 main
	ChairMan::singleMan;

	ChairMan *cm1 = ChairMan::singleMan;



	system("pause");
	return 0;
}

安全的改进

#include <iostream>

using namespace std;

// 创建列中的对象，并且保证只有一个对象可以使用，一个对象实例。

class ChairMan
{
private:
	// 1.将构造函数自由化，改成private
	// 
	ChairMan(){ cout << "create super" << endl; }
	ChairMan(const ChairMan &ch) {};
private:
	static ChairMan *singleMan;
public:
	// 通过提供的接口实现访问
	static ChairMan* getInstance()
	{
		return singleMan;
	}
};

ChairMan * ChairMan::singleMan = new ChairMan;

int main(int argc, char *argv[])
{
	ChairMan * cm1 = ChairMan::getInstance();
	ChairMan * cm2 = ChairMan::getInstance();
	if (cm1 == cm2)
		cout << "相等" << endl;

	// 现在其实也能改? 下面可以强改,加上拷贝构造，直接完事。
	ChairMan *cm3 = new ChairMan(*cm2);
	if (cm2 == cm3)
		cout << "不相等" << endl;


	system("pause");
	return 0;
}

打印机的单例模式案例。

#include <iostream>
#include <string>

using namespace std;

class Printer
{
private:
	static Printer * singlePrinter;

private:
	Printer(){ };
	Printer(const Printer & ptr);

public:
	static Printer * getInstance()
	{
		return singlePrinter;
	}
	static void PrintText(string text)
	{
		cout << text << endl;
	}
};

Printer * Printer::singlePrinter = new Printer;


int main(int argc, char *argv[])
{
	// 拿到打印机对象指针,后期通过该指针操作数据
	Printer * ptr = Printer::getInstance();

	ptr->PrintText("hello lyshark");   // 调用打印机

	system("pause");
	return 0;
}

this 指针: this指针指向被调用的成员函数所属的对象，

#include <iostream>
#include <string>

using namespace std;

class Person
{
public:
	char *name;
	int age;

public:
	Person(char *p_name, int p_age) { this->name = p_name; this->age = p_age; }

	void Compare_Age(Person & ptr)       // 对比年龄是否相等
	{
		if (this->age == ptr.age)
			cout << "Same age" << endl;     // 年龄相同
		else
			cout << "Same not age" << endl; // 年龄不同
	}

	void PlusAge(Person & ptr)   // 两个年龄相加
	{
		this->age += ptr.age;
	}

	Person & Push_Age(Person &ptr)
	{
		this->age += ptr.age;
		return *this;         // 返回指向对象本体
	}

};

int main(int argc, char *argv[])
{
	Person per1("lyshark", 33);
	Person per2("admin", 33);
	// ----------------------------------------
	per1.Compare_Age(per2);      // 判断两个类年龄是否相等
	// ----------------------------------------
	per1.PlusAge(per2);          // 将两个年龄相加
	cout << per1.age << endl;    // 输出年龄
	// ----------------------------------------

	per1.Push_Age(per2).Push_Age(per2);  // 链式编程(必须传递引用)
	cout << per1.age << endl;

	system("pause");
	return 0;
}

空指针访问成员函数: 如果用不到this则可以调用，用到的话就会报错。

#include <iostream>
#include <string>

using namespace std;

class Person
{
public:
	int m_age;

public:
	void show() { cout << "person show" << endl; }
	void show_age() 
	{
		if (this == NULL)   // 防止使用空指针访问
			return;
		cout << "show: "<< m_age << endl;
	}
};

int main(int argc, char *argv[])
{

	Person *ptr = NULL;

	ptr->show();          // 这个可以
	ptr->show_age();      // 不可以

	// show_age() 默认会加上 this --> 那么如果传递空指针则失败
	// 代码接收空指针,会溢出

	system("pause");
	return 0;
}

常函数、常对象： 使用const 修饰成员函数，则是常函数，

#include <iostream>
#include <string>

using namespace std;

class Person
{
public:
	int m_x;
	int m_y;

public:
	Person()
	{
		this->m_x = 0;
		this->m_y = 0;
	}

	void showInfo() const // 声明常函数,函数内部不可有修改指针的指向
	{
		 // this->m_x = 1000; 相当于修改成了: --> const Person * const this
		cout << this->m_x << endl;
		cout << this->m_y << endl;
	}
};


int main(int argc, char *argv[])
{
	Person per1;
	per1.showInfo();

	// 定义常对象，常对象不允许修改数据。
	const Person per2;

	system("pause");
	return 0;
}

友元函数的定义(全局函数): 将全局函数定义为友元函数，让外部函数，可以访问类内部的私有数据。

#include <iostream>
#include <string>

using namespace std;

class Building
{

	friend void goodGay(Building *building);
private:
	string m_badRoom;        // 私有的卧室
	string m_sittingRoom;    // 客厅

public:
	Building()
	{
		this->m_sittingRoom = "客厅";
		this->m_badRoom = "卧室";
	}
};

// 全局函数,我想让他能访问到私有的卧室
void goodGay(Building *building)
{
	cout << "访问我的客厅:" << building->m_badRoom << endl;
	cout << "访问我的卧室:" << building->m_sittingRoom << endl;

}

int main(int argc, char *argv[])
{
	Building *building = new Building;
	goodGay(building);


	system("pause");
	return 0;
}

让整个类做友元类:

#include <iostream>
#include <string>

using namespace std;

class Teacher
{
	friend class Student;  // 让Student学生,可以访问我的私有成员

private:
	char * m_school;     // 老师所在的学校
	char * m_class;      // 老师所教的班级

public:
	Teacher()
	{
		this->m_school = "中心小学";
		this->m_class = "一年级二班";
	}
};

class Student
{
private:
	Teacher *ptr;         // 设置一个指向teacher的指针

public:
	Student()
	{
		ptr = new Teacher; // 初始化一下
	}
	void Display()
	{
		cout << "学生访问到的学校: " << this->ptr->m_school << endl;
		cout << "学生访问到的班级: " << this->ptr->m_class << endl;
	}
};

int main(int argc, char *argv[])
{

	Student stu;
	stu.Display();

	system("pause");
	return 0;
}