【C++】类（public，private）
目录
访问修饰符
this指针
this->可以省略
重名问题（就近原则）
第一种：传入参数名与类中变量名重复
第二种：类中变量名与全局变量名重复
第三种：类中函数名和全局函数名重复
命名规范
类的封装
类的头文件和源文件分离
说到类，就不得不提struct（对照struct博客来理解类），毕竟类是再struct的基础上进行了功能增强。
class Object
{
int a;
int b;
double c;
};访问修饰符
public：表示类的成员可以被外部访问；
private：表示类的成员不可以被外部访问。
class Object
{
public:
int a;
int b;
void Test()
{
printf("Hello, i am test.\n");
}
private:
double c;
};
int main()
{
Object a;
a.a = 1;
a.b = 2;
a.Test();
Object* b = &a;
printf("%d \n", b->a);
std::cout << "Hello World!\n";
return 0;
}this指针
其实就是为了方便，不然你要手动传对象指针，比较人性化点。
#include "stdio.h"
class Object
{
public:
int a;
int b;
//传统C语言方式，传一个指针进去
void Test(Object* that)
{
printf("Hello, i am test.\n");
printf("C:%d\n", that->a);
}
//C++直接就在类内部实现了这个功能
void Test_CPP()
{
printf("CPP:%d \n", this->b);
}
int Add()
{
return this->a + this->b;
}
//C++直接就在类内部实现了这个功能
void Test_add()
{
printf("Add:%d \n", this->Add());
}
};
int main()
{
Object a;
a.a = 1;
a.b = 2;
a.Test(&a);
a.Test_CPP();
a.Test_add();
std::cout << "Hello World!\n";
return 0;
}
就算被private修饰，在class内部依旧可以使用，反正都是自己的怕什么，随便用。例子：
#include "stdio.h"
class Object
{
private:
int a;
int b;
//传统C语言方式，传一个指针进去
public:
void Set_value(int a, int b)
{
this->a = a;
this->b = b;
}
int Add()
{
return this->a + this->b;
}
//C++直接就在类内部实现了这个功能
void Test_add()
{
printf("Add:%d \n", this->Add());
}
void Print_this()
{
printf("this:%p\n", this); //打印this地址
}
};
int main()
{
Object a;
printf("a:%p\n", &a);//打印对象地址
a.Print_this();
a.Set_value(2, 6); //设置值
a.Test_add(); //加法并打印
std::cout << "Hello World!\n";
return 0;
}
可以看出对象a和this的指针是一样的。
this->可以省略
就是在类的内部可以不用this也能使用本身的变量和函数。
#include "stdio.h"
class Object
{
private:
int a = 1;
int b = 3;
//传统C语言方式，传一个指针进去
public:
void Set_value(int a, int b)
{
this->a = a;
this->b = b;
}
int Add()
{
return this->a + this->b; //相当于 return a + b;
}
int Reduce()
{
return a - b;
}
void Test_func()
{
printf("Reduce:%d \n", this->Reduce());
}
void Print_this()
{
printf("this:%p\n", this);
}
};
int main()
{
Object a;
printf("a:%p\n", &a);
a.Print_this();
a.Set_value(2, 6); //设置值
a.Test_func(); //加法并打印
std::cout << "Hello World!\n";
return 0;
}重名问题（就近原则）
第一种：传入参数名与类中变量名重复
#include "stdio.h"
class Object
{
public:
int a;
int b;
void Test_func(int a)
{
printf("Repeat:%d \n", a);
}
};
int main()
{
Object a;
a.a = 10;
a.Test_func(5); //加法并打印
std::cout << "Hello World!\n";
return 0;
}结果为：
Repeat:5
Hello World
分析：从结果看出Test_func中的参数是a=5，类中也有一个变量a=10，它两值不一样，最终打印了传入的值5。所以这符合就近原则。如果想调用类中的a，可以使用this->a
第二种：类中变量名与全局变量名重复
使用::调用全局变量
#include "stdio.h"
int a = 100; //全局变量
class Object
{
public:
int a;
int b;
void Test_func()
{
printf("Repeat:%d \n", ::a);
}
};
int main()
{
Object a;
a.a = 10;
a.Test_func(); //加法并打印
std::cout << "Hello World!\n";
return 0;
}其结果为：
Repeat:100
Hello World
打印了全局变量，因为我在a前面加了限定符::
第三种：类中函数名和全局函数名重复
访问全局函数，在函数名前加入::
#include "stdio.h"
int a = 100; //全局变量
int Sum(int a, int b)
{
return a + b;
}
class Object
{
public:
int a;
int b;
int Sum(int a, int b)
{
return a*2 + b;
}
void Test_func()
{
printf("Repeat:%d \n", ::Sum(a, b)); // 访问全局Sum函数
}
};
int main()
{
Object a;
a.a = 10;
a.b = 20;
a.Test_func(); //加法并打印
std::cout << "Hello World!\n";
return 0;
}命名规范
类名：名词，首字母大写（也可以加下划线分隔）
成员函数：动词，首字母大写（也可以加下划线分隔）
成员变量：小写字母，通常加上前缀m_（我感觉这个无所谓了，定义的名字有实际意义就行）
类的封装
封装，顾名思义就是将内部实现封装成一个黑盒，只提供接口，其他使用者只能通过接口调用。
封装其实就是通过访问修饰符来实现的。
#include "stdio.h"
class Object
{
private:
int m_a;
int m_b;
int m_radius;
public:
int GetA() //只读功能
{
return m_a;
}
int GetB()
{
return m_a;
}
int SetRadius(int radius) //只写功能
{
this->m_radius = radius;
}
};类的头文件和源文件分离
（1）成员变量，还是写在类里面
（2）成员函数，在类里面保留申明，而函数的具体实现写在类体之外；
（3）写在类体之外的函数记得加上Object::（类名::）
#include "stdio.h"
class Object
{
public:
int x;
void Test();
};
void Object::Test()
{
printf("This is outside implementation.");
}
int main()
{
Object obj;
obj.Test();
std::cout << "Hello World!\n";
return 0;
}头文件和类的实现分离时，要注意编译器环境。
main.cpp
#include "pch.h"
#include
#include "Object.h"
int main()
{
Object obj;
obj.x = 1;
obj.Test();
std::cout << "Hello World!\n";
return 0;
} Object.cpp
#include "pch.h"
#include "Object.h"
#include "iostream"
using namespace std;
void Object::Test()
{
cout << "x is " << x << endl;
}Object.h
头文件一般情况下要加入#ifndef #define #endif，这样可以防止该头文件被重复定义。
我们得了解到include就相当于将对应的.h头文件直接copy到主程序中，如果你引用了2次头文件，岂不是说你申明了2个完全相同的变量或者函数，这显然是不被允许的。所以就得加#ifndef #define #endif
#pragma once
#ifndef _OBJECT_H
#define _OBJECT_H
class Object
{
public:;
int x;
void Test();
};
#endif请注意：
（1）不一定要将所有函数都拿到cpp中实现，在头文件中也是可以写函数的实现的。
但一般情况，只给用户看接口，具体的实现时不让用户看得的，所以就需要将实现都写到cpp中。
那么写在类体之内和类体之外有什么区别呢？
写在类体里面相当于inline函数，写在类体之外，则是普通的函数。
（2）在类体中，成员函数与成员变量的排列顺序是自由的。