C++类的演示1

data.h

#pragma once
#include <stdio.h>
#include <string>
class TData
{
private:
	//类中定义的变量，是不能进行初始化的，初始化只能在构造函数中完成！
	//	例如：int day = 1; 这样是错误的！
	int day_;
	int month_;
	int year_;
	char* msg;
public:
	//定义一个类的静态成员变量
	static int count; //这里不能进行静态成员变量的初始化，初始化需要放到data.cpp中
	//可以直接在定义类里面完成函数功能
	void set_data(const int day, const int month, const int year)
	{
		this->day_ = day;
		this->month_ = month;
		this->year_ = year;
	}

	void get_data();
	//默认构造函数
	TData();
	//重载构造函数
	TData(int day, int month, int year);
	//析构函数
	~TData();
	//内联函数
	inline int get_year();
	//友元函数
	friend int get_day(TData data);
	//const修饰过的函数
	int get_mouth() const;
	void set_msg(const char * msg);
	void showMessage();

	//复制构造函数
	TData(TData& data);
};

/*
 *内联函数：
 *1：内联函数必须放在头文件或者调用的CPP里
 *2：内联函数尽量不要使用过多的代码，在内联函数中，编译器会设法以函数体的代码代替函数的调用。
 *这样可以避免调用函数的开销，因此加速代码的运行。如果函数内代码过多，会增加程序体积。
 */
inline int TData::get_year()
{
	return this->year_;
}

data.cpp

#include "data.h"

//静态成员变量的初始化
int TData::count = 0;

TData::~TData()
{
	//析构函数，可以在类结束使用的时候进行调用。
	delete[] this->msg;
	printf("执行析构函数！\n");
}
TData::TData()
{
	this->day_ = 30;
	this->month_ = 3;
	this->year_ = 2024;
	this->msg = new char[256];
	memset(this->msg, 0, sizeof(this->msg));
	printf("执行构造函数1\n");
	count ++;
}

TData::TData(int day, int month, int year)
{
	this->day_ = day;
	this->month_ = month;
	this->year_ = year;
	printf("执行构造函数2\n");
	count ++;
	this->msg = new char[256];
	memset(this->msg, 0, sizeof(this->msg));
}

void TData::get_data()
{
	printf("%d年%d月%d日\n", this->year_, this->month_, this->day_);
	return;
}

//const修饰的类中函数
int TData::get_mouth() const
{
	return this->month_;
}

void TData::set_msg(const char* msg)
{
	strcpy_s(this->msg, 256, msg);
}

void TData:: showMessage()
{
	printf("打印的msg为：%s\n", this->msg);
}

//复制构造函数
TData::TData(TData& data)
{
	this->msg = new char[256];
	memset(this->msg, 0, sizeof(this->msg));
	strcpy_s(this->msg, 256, data.msg);
	//类中的其它变量，也需要手动赋值，这里省略了。
}

Main.cpp

#include "data.h"

int get_day(TData data)
{
	//友元函数可以直接调用私有变量
	return data.day_;
}
void Myfunction()
{
	//类实例化
	//data中的this指针，实际上相当于&data;this指针只能在类的内部使用。
	//可以使用this指针访问类中的成员变量和成员函数。
	TData data(21,2,1999);
	printf("Myfunction执行完毕！\n");
	printf("打印内联函数:%d\n", data.get_year());
	printf("打印友元函数的内容%d\n", get_day(data));

	//用const修饰过的类，除了构造函数和析构函数以外，不允许使用过程中再修改里面的内容。
	const TData data2(31,3,2000);
	//const定义的类在调用函数时，可以调用的函数也必须经过const进行修饰
	printf("调用const修饰过的函数:%d\n", data2.get_mouth());
	//静态成员变量是做为当前类的共享内存使用。
	//在多线程中使用类的静态成员变量，需要上锁
	printf("类被初始化的次数：%d\n", TData::count);
	//类的引用
	TData& data3 = data;
	printf("类的引用%d\n", data3.get_year());
	//类的复制
	TData data4 = data;
	printf("类的复制%d\n", data4.get_year());

	TData data5;
	data5.set_msg("好好学习!");
	TData data6 = data5;
	data5.set_msg("asdasdasd");
	//打印出来的内容是asdasdasd，
	//原因：data6在复制data5时，并没有在默认的构造函数中进行new,而是直接把类中的char* msg的指针也直接给复制过去了
	//所以两个指针指向了同一个地址。解决办法：默认复制构造函数。
	//★要看复制构造函数使用与不使用的区别，需要手动把类中的复制构造函数注释掉。
	data6.showMessage();
	return;
}
int main(){

	Myfunction();
	getchar();
	return 0;
}