类与类成员的访问

beyes

类定义的通用形式：

[C++] 纯文本查看 复制代码

class class-name {
    private data and functions
public:
   public data and functions
} object-list;

上面的 class-name 指定了类的名字，这个类名将成为一种新类型的名字，并可以藉此来创建类的对象。在类中，由 public 关键字声明的部分是公有成员，在此之外的是私有成员。

类的公有成员对外部代码开放，外部代码访可以通过点运算符访问公有成员，就像访问结构体变量中的成员那样。比如定义了下面一个类：

[C++] 纯文本查看 复制代码

class testclass {
        int pri_var;
        void subvar(int b);
public:
        int pub_var;
        void op_init();
        int op_var(int a);
        void op_subvar(int k);
};

这个类中有一个公有成员变量 pub_var 。那么我们在 main() 函数中可以先声明出一个 testclass 类类型的对象，然后通过这个对象来访问这个公有成员变量：

[C++] 纯文本查看 复制代码

int main()
{
        testclass myclass;
        myclass.pub_var = 10;
        cout << "we can access the public variable directly from main(),pub_var:" << myclass.pub_var << '\n';
        return 0;
}

运行输出：

$ ./class
we can access the public variable directly from main(),pub_var:10

但是我们不能通过对象及点运算符直接访问私有成员变量，如 myclass.pri_var = 20; 这样就会编译报错：

$ g++ class.cc -o class
class.cc: In function ‘int main()’:
class.cc:5: 错误：‘int testclass::pri_var’ 是私有的
class.cc:45: 错误：在此上下文中

访问私有成员变量只能通过类的成员函数，当然类的成员函数也可以访问公有成员变量。比如我们将类中的初始化函数 op_init(); 写成：

[C++] 纯文本查看 复制代码

void testclass::op_init()
{
        pri_var = 0;
        pub_var = 0;
}

在这个初始化函数里同时对私有成员变量  pri_var 和 公有成员变量 pub_var 进行了初始化。

另外，私有成员函数也是不能通过对象直接由点运算符来访问的，比如 myclass.subvar(3); 这种用法也会报以同样的错误信息：

$ g++ class.cc -o class
class.cc: In function ‘int main()’:
class.cc:26: 错误：‘void testclass::subvar(int)’ 是私有的
class.cc:45: 错误：在此上下文中

下面以一个完整的例子简单的说明对类成员的访问：

[C++] 纯文本查看 复制代码

#include <iostream>
using namespace std;

class testclass {
        int pri_var;
        int subvar(int b);
public:
        int pub_var;
        void op_init();
        int op_var(int a);
        int op_subvar(int k);
};

void testclass::op_init()
{
        pri_var = 0;
        pub_var = 0;
}

int testclass::op_var (int a)
{
        pri_var += a;
        return pri_var;
}

int testclass::subvar(int b)
{
        pri_var -= b;
        return pri_var;
}

int testclass::op_subvar(int k)
{
        return subvar(k);
}

int main()
{
        testclass myclass;

        myclass.op_init();

        myclass.pub_var = 10;
        cout << "we can access the public variable directly from main(),pub_var:" << myclass.pub_var << '\n';

        cout << "private variable pri_var is:" << myclass.op_var(30) << '\n';

        cout << "after subtraction, pri_var is:" << myclass.op_subvar(12) << '\n';

        return 0;
}

运行输出：

$ ./class
we can access the public variable directly from main(),pub_var:10
private variable pri_var is:30
after subtraction, pri_var is:18

最后总结一下，当创建了类的一个对象时，对象在内存中便拥有了一份属于自己的成员变量副本。也就是说，同属于一个类的两个对象它们有各自的成员副本，它们之间的数据是相互独立的。对象是在物理上存在的，它是类的一个实例。换句话就是说，对象可以占有内存空间，而类则不能。

要实现类的成员函数，就必须告诉编译器这个成员函数属于哪个类，方法就是在函数的名字前面加上类的名字，其中 :: 符号被称为域解析运算符。所以，有这个域运算符的限定后，不同的类中便可以使用相同的函数名而不会冲突了。