掘根大全之C++对象和类（创建类，访问类成员，public，private，定义类方法，const成员函数）
怎么创建类
我们先了解一下相关术语
类成员：在类里声明或定义的所有东西
类数据成员：在类里声明或定义的变量
类方法：在类里声明或定义的函数
c++用class关键字来创建类，创建格式是
class 类名
{
类数据成员，类方法
...
};//不要忘记了分号以下是一个简单的C++类的示例：
class AA{
public:
// 成员函数的声明和定义
void A(int a_);
private:
// 成员变量
int a;
};
// 成员函数的定义
void AA::A(int a_) {
a = a_;
}
在上面的示例中，我们定义了一个名为AA的类，它有一个私有的成员变量a和一个公有的成员函数AA。成员变量a是私有的，只能在类的内部访问；而成员函数A是公有的，可以从类的外部调用。
通过类的定义，我们可以创建AA的对象，并通过对象来访问成员变量和成员函数。
可能我们会有一点懵啊，类？对象？public?private?什么玩意?
别急啊，我们一一解答
如何访问类成员
我们可以用成员访问运算符点（.）来访问类对象成员
例如：
AA A;//创建一个AA类的对象
A.A(22);调用A对象的成员函数
在这个例子中，我们创建了一个AA的对象A，并通过对象调用成员函数A()。
类和对象的区别
我们先就代码而言来区分类和对象啊
class AA
{
......
}这时上面这个AA就是一个类
AA a;上面这a就是一个对象
你会发现它们有关系，哈哈，你猜对了。
它们之间的关系类似于人类和某一个具体的人（比如说你），上面的AA代表人类，对象a代表你，整体和个体的关系
还不明白？我们可以看看代码
int b;类和对象的关系就像这int和b的关系，通过int类型我们可以创建多个int变量，同理我们通过类也能创建多个对象，也是整体和局部的关系
接下来我们来看看它们的区别
在C++中，类和对象是面向对象编程的两个重要概念，它们有以下区别：
-
定义和声明：类是用户自定义的数据类型，用于描述对象的属性和行为。类被定义为一个模板，包含成员变量和成员函数的声明和定义。而对象是类的实例化，通过类创建的具体实体，可以使用类中定义的成员变量和成员函数。
-
内存分配：类是一种抽象概念，不占用内存空间。而对象是具体的数据实体，在内存中占有实际的空间。
-
访问权限：类中的成员变量和成员函数可以使用访问修饰符（public、private、protected）来定义访问权限。类的外部只能访问公有成员，不能直接访问私有成员。对象可以通过成员访问运算符"."来访问类中的成员。
-
数据共享：类中的成员变量是所有对象共享的，即所有对象都存储相同的成员变量副本。而对象是独立的实体，每个对象都有自己的成员变量。
-
动态性：类是静态定义的，编译时就确定了类的结构和成员。而对象是动态创建的，可以在运行时根据需要创建和销毁对象。
总之，类是定义和描述对象的模板，是抽象的概念；而对象是类的具体实例，是具体的数据实体。类定义了对象的属性和行为，通过对象可以访问和操作类中定义的成员。
访问控制（public和private)
C++中的类成员有三种访问控制，分别是私有访问(private)，保护访问(protected)和公有访问(public)。
私有访问(private)：私有成员只能在类内部访问，对外部是不可见的。这意味着，私有成员不能被类的对象直接访问，也不能被类的派生类访问。私有成员通常用于实现类的内部细节，对外部隐藏。可以通过公有成员函数来间接访问私有成员。
保护访问(protected)：保护成员可以在类内部访问，也可以在派生类中访问，但对外部是不可见的。保护成员通常用于在派生类中访问和修改基类的成员。
公有访问(public)：公有成员可以在类内部访问，也可以在外部通过类的对象访问。公有成员通常用于类的接口，提供给外部使用。
可以使用访问说明符(access specifier)来指定成员的访问控制，如下所示：
class AA {
public:
// 公有成员
protected:
// 保护成员
private:
// 私有成员
};
需要注意的是，访问控制是应用于类的成员级别，而不是类级别。也就是说，访问控制只对成员的访问有效，对类本身的访问没有影响。
我们这里就先介绍private和public，因为protected是用于类继承的，我们这里暂时用不到。
关键字private和关键字public描述了对类成员的访问控制。使用类对象的程序都可以直接访问公有部分，但只能通过公有成员函数（或者友元函数）来访问类对象的私有成员。
我们可以举个例子
#include
using namespace std;
class AA
{
private://私有部分
int a = 1;
public://公有部分
int b = 2;
void H()
{
cout << a << endl;
}
};
int main()
{
AA a;
cout << a.b << endl;//用点来访问类对象的公有部分，结果是2
a.H();//打印出1，类对象的私有数据只能被公有方法（或友元函数）访问
cout< 用点来访问类对象的公有部分没有一点问题，
类对象的私有部分只能由类对象的公有成员函数（或者友元函数）访问
有人可能想问了啊，难道类的私有成员函数就不可以访问类的私有成员吗？还有友元函数是个什么东东？别急，掘根这就为大家解惑！
首先，类的私有成员函数就可以访问类的私有成员，但是我们不建议将函数设置为私有的，除了一些特殊情况，因为使用起来很麻烦
我们可以看个例子
#include
using namespace std;
class AA
{
private:
int a = 1;
void H()//私有成员函数
{
cout << a << endl;
}
public:
int b = 2;
void dH()
{
H();//公有成员函数调用私有成员函数
}
};
int main()
{
AA a;
a.dH();
} 私有成员函数只能被公有成员函数调用，这就显得调用私有成员函数很麻烦噢！！
因此我们通常将数据成员放在private部分，将成员函数放在public部分
其次，友元函数大家可以自己先去了解了解，我们这篇博客不会讲它，要是感兴趣的话，可以去看看其他博主的文章或者等掘根后续的更新
类对象的默认访问权限（private)
值得注意的是啊
我们可以不必在类声明中使用关键字private，因为这是类对象的默认访问控制
大家可能不懂啊，我们举个例子
#include
using namespace std;
class AA
{
int a = 1;
};
int main()
{
AA W;
cout< 我们可以看到啊，编译器报错了，这说明类对象把a变量默认为私有的了！！！
类和结构
我们学了类，发现类和结构的定义格式和使用方法是类似的啊。
c++通常用类来实现类描述，而把结构限制为只表示存粹的数据对象
它们的默认访问权限不同
类对象的默认访问权限是private,而结构的默认访问权限是public
实现类成员函数
一般情况下，我们在类里面只声明函数原型，不会给定义，这时我们就需要在类外给成员函数定义。那怎么做呢？
在类外定义成员函数时，使用作用域运算符（::）来标识函数所属的类
我们可以看个例子
#include
using namespace std;
class AA
{
public:
void dH()；//类成员函数声明
};
void AA::dh()//注意使用限定的名称
{
cout<<"定义成功“< 这样子我们也是成功在AA类外定义的AA类的dH()函数
那有人就想问了啊
如果我要想在类内使用dH函数，需不需要作用域解析运算符(：：)？
答案是不用的，因为标识符dH在AA类里具有类作用域，AA类的其他类成员函数不必使用作用域解析运算符，就可以使用dH（）方法，因为它们属于同一个类的
其次啊，类成员函数可以直接访问类的私有成员
内联方法
如果对内联函数不熟悉的，可以看看这篇博客http://t.csdnimg.cn/FB3kh
其定义位于类声明中的函数都将自动成为内联函数，类声明通常将短小的成员函数作为内联函数
我们可以举个例子
class AA
{
public:
void D()
{
cout<<"D是内联函数"<如果愿意，也可以在类声明之外定义成员函数，并使其成为内联函数，只需在类实现部分定义函数时使用inline限定符即可
举个例子
class AA
{
public:
void A();
};
inline void AA::A()
{
cout<<"A是内联函数"<内联函数的特殊规则要求在每个使用它们的文件里都对其进行定义。
因此，我们应该将内联定义放在定义类的头文件中
方法使用哪个对象
首先，我想说，我们所创建的每个新对象都有自己的存储空间，用于存储其内部变量和类成员，但同一个类的所有对象共享同一组类方法，即无论创建多少个对象，每种方法只有一个副本
举个例子
class AA
{
public:
void cc():
...
};
...
int main()
{
AA a,b:
a.cc();//cc函数使用a的数据成员
b.cc（）;//cc函数使用b的数据成员
...
}a,b各有自己的数据成员，但是它们共用同一组类方法
这时类方法该使用哪个对象的数据呢？
自然是哪个对象调用的类方法就用谁的数据喽
const成员函数
我们看下面这个例子
#include
using namespace std;
class AA
{
private:
int a_;
public:
AA(int a)
{
a_ = a;
}
void B()
{cout<<"调用成功"< 把对象声明为const的了就发现不能正常调用它的函数了，那怎么办呢？
解法是C++将const关键字放在函数的括号后面。保证函数不会修改调用对象。
也就是说，我们如果想调用B（）函数，就得像下面这么写
#include
using namespace std;
class AA
{
private:
int a_;
public:
AA(int a)
{
a_ = a;
}
void B() const //后面加const
{cout<<"调用成功"< 因此我们定了一个规矩，只要类方法不修改调用对象，就得在该函数原型和定义后加上const