2.类与对象-CSDN博客

本文链接：https://blog.csdn.net/weixin_51310062/article/details/137748322

类中成员关键字介绍：

public : 当类的成员被声明为 public 时，它们可以在任何地方被访问。这包括类的内部、类的派生类（如果有的话）以及类的实例（对象）。

private : 当类的成员被声明为 private 时，它们只能在类的内部被访问。这意味着它们不能从类的外部或派生类中被直接访问。

protected : protected 成员的行为与 private 成员类似，但它们还有一个额外的特性：它们可以在派生类中被访问。这意味着，如果一个类从另一个类继承，并且基类中的某个成员被声明为 protected，则派生类可以访问这个成员。

1.类的申明

1.1 函数范例

#include <stdio.h>
/*类的使用*/
class A {
public:  //公共的，成员函数

	A()  //类的构造函数，主动调用，无参构造函数，初始化的作用
	{
		printf("construct !!!!!!!\n");
		a = 0;
	}

	A(int data)  //类的构造函数，主动调用，有参构造函数，初始化的作用
	{
		a = data;
	}

	~A()         //类的析构函数 释放对象所占用的资源，没有返回值和参数，释放动态分配的内存，关闭打开的文件
	{
		printf("dddddddddddd\n");
	}

	void show()
	{
		printf("xxxxx\n");
	}

	void setdata(int data)
	{
		a = data;
	}
	int getdata(void);
private:        //私有的，数据成员
	int a;
};

int A::getdata(void)
{
	return a;
}
int main()
{
	//A x;
	A x(100); //初始化传参，调用的是有参构造函数，不调用无参构造函数。
	/*如果要改变a的值，必须在public中定义函数传参接口,否则不能改变private中a的值*/
	//x.a = 100; //错误
	//x.setdata(100); //正确方法

	printf("%d\n",x.getdata());
	x.show();
	return 0;
}

类：由方法成员和数据成员组成，

构造函数和析构函数在public中，主要作用：

确保对象在创建时处于一个有效的状态，
在对象生命周期结束时释放资源，防止内存泄露。

1.2 普通成员函数输出

执行普通成员函数，必须要构造出对象，通过对象调用出普通成员函数。

#include <stdio.h>

class A{
public:
		void func(void)
		{
			printf("XXXXXXXXXX\n");
		}
};

int main(int argc,char *argv[])
{
	A a;
	a.func();

	return 0;
}

1.3 数据成员输出

#include <stdio.h>

class A{
public:
    /**析构函数初始化表初始化变量的值**/
	A():a(0){   
	} 
	
	void setA(int value){
		a = value; 
	}

	void fun(void){
		printf("data = %d\n",a);
	}

private:
	int a;
};

int main(int argc,char *argv[])
{
	A x;
	x.setA(100);
	x.fun();
	return 0;
}

2.类的成员函数

3.常成员、常对象

函数举例：

#include <stdio.h>

class A{
	public: 
			/*构造函数*/
			A(int a = 50,int data = 1000):b(data){
				this->a = a;
				printf("AAAAAAAAAAA\n");
			}
			/*析沟函数*/
			~A(){
				printf("~~~~~~~~~~~~\n");
			}
			/*常成员函数*/
			void show(void) const{
				printf("b = %d\n",b);
				printf("a = %d\n",a);
			}

	private:
			int a;
			const int b;
};

int main(int argc,char *argv[])
{
	A x(100);
	x.show();
	A y(200);
	y.show();

	A z;
	z.show();

	return 0;
}

4.静态成员

基于类不基于对象的一种方式

4.1 静态成员函数

#include <stdio.h>

class A{
public:
		static void func(void)
		{
			printf("XXXXXXXXXX\n");
		}
};

int main(int argc,char *argv[])
{
	A a;   //定义对象
	a.func();//基于对象调用函数

	A::func(); //基于类调用函数，函数需要加static

	return 0;
}

4.2 静态数据成员

#include <stdio.h>

class A{
public:
		static void func(void)
		{
			printf("XXXXXXXXXX\n");
		}

		static int data;
};

int A::data = 10;  //静态数据成员类外初始化

int main(int argc,char *argv[])
{
	A a;   //定义对象
	a.func();//基于对象调用函数
	A::func(); //基于类调用函数，函数需要加static

	A x; //定义对象
	x.data = 100;//基于对象赋值变量
    printf("x.data = %d\n",x.data);  
	A::data = 1000;//基于类赋值变量，变量前要加static
    printf("x.data = %d\n",x.data);  
	return 0;
}