类的进化史

　　类无疑是C++最重要的概念之一，是从C的面向过程到C++面向对象的重要转变的基础，下面我们就来谈谈C++中的类是怎样演变的。

　　先来看看C中的结构体（struct），结构体是一组属性的集合体，举一个简单的栗子，struct point{float i; float j;};这样就把平面内一个点的两个属性捆绑到了一起，这样的好处是显而易见的，试想一下，如果没有结构体，每次定义一个点都需要定义两个变量，无论是管理还是使用起来都是非常的不方便。通过struct把一组相关联的属性捆绑在一起，无疑是十分明智的选择。

　　下面我们再来看看C库的栗子，C库便是把一系列相关联的数据和操作放在了一起，为了方便之后调用，增加代码复用性，提高开发效率而存在的。这里有一个简单的C库栗子：

// CLib.h
// Header file fr a C-like library
// An array-like entity created at runtime
typedef struct CStashTag{
    int size;
    int quantity;
    int next;
    unsigned char* storage;
}CStash;

void initialize(CStash* s, int size);
void cleanup(CStash* s);
int add(CStash* s, const void* element);
void* fetch(CStash* s, int index);
int count(CStash* s);
void inflate(CStash* s, int increase);

// Clib.cpp {0}
// Implementation of example C-like library
// Declare structure and functions:
#include "Clib.h"
#include <iostream>
#include <cassert>
using namespace std;

const int increment = 100;

void initialize(CStash* s, int sz){
    s->size = sz;
    s->quantity = 0;
    s->storage = 0;
    s->next = 0;
}

int add(CStash* s, const void* element){
    if(s->next >= s->quantity)
        inflate(s, increment);
    int startBytes = s->next * s->size;
    unsigned char* e = (unsigned char*)element;
    for(int i = 0; i < s->size; i++)
        s->storage[startBytes + i] = e[i];
    s->next++;
    return(s->next -1);
}

void* fetch(CStash* s, int index){
    assert(0 <= index);
    if(index >= s->next)
        return 0;
    return &(s->storage[index * s->size]);
}

int count(CStash* s){
    return s->next ;
}

void inflate(CStash* s, int increase){
    assert(increase > 0);
    int newQuantity = s->quantity + increase;
    int newBytes = newQuantity * s->size;
    int oldBytes = s->quantity * s->size;
    unsigned char* b = new unsigned char[newBytes];
    for(int i = 0; i < oldBytes; i++)
        b[i] = s->storage[i];
    delete [](s->storage);
    s->storage = b;
    s->quantity = newQuantity;
}

void cleanup(CStash* s){
    if(s->storage != 0){
        cout << "freeing storage" << endl;
        delete []s->storage;
    }
}

　　这只是为了方便演示所创建的简单代码，暂时先不考虑其他要素（如：使用#ifndef来防止重复包含）。

　　这个库中提供了一个结构体以及CStash，以及围绕这个结构体的一系列函数，通过使用库，可以比较方便的复用这段代码，而不必在每次开发时重写一遍。下面时使用这个库的一个栗子：

// CLibTest.cpp
// CLib
// Test the C-like library
#include "CLib.h"
#include <fstream>
#include <iostream>
#include <string>
#include <cassert>
using namespace std;

int main(){
    CStash intStash, stringStash;
    int i;
    char* cp;
    ifstream in;
    string line;
    const int bufsize = 80;
    initialize(&intStash, sizeof(int));
    for(i = 0; i < 100; i++)
        add(&intStash, &i);
    for(i = 0; i < count(&intStash); i++)
        cout << "fetch(&intStash, " << i << ") = "
             << *(int*)fetch(&intStash, i)
             << endl;
    initialize(&stringStash, sizeof(char)* bufsize);
    in.open("CLib.cpp");
    assert(in);
    while(getline(in, line))
        add(&stringStash, line.c_str());
    i = 0;
    while((cp = (char*)fetch(&stringStash, i++)) != 0)
        cout << "fetch(&stringStash, " << i << ") = "
             << cp << endl;
    cleanup(&intStash);
    cleanup(&stringStash);
}

　　在测试文档中，只需要引入这个库，然后便能像其它类型那样定义CStash类，并用库中的函数对它进行操作。看起来似乎很棒，但仔细想想便会发现诸多不方便的地方。

　　首先，每个函数都需要向其中传入一个结构体的地址，这看起来有些多余。其次，如果引入两个库，它们都包含相同的函数名称，则会出现错误，因为它们共用同一个的命名空间，链接器会在主表查询，当发现两个定义不同的同名函数，必然会报错。其实这也是C库的一个最麻烦的地方，那就是命名冲突。因为像initialize和cleanup这样通俗的名字也许很多库的开发者都会觉得是个不错的选择而使用它们，因此，为了避免这样的冲突，库中的函数往往都需要带上特殊的前缀。这时，我们这个库的函数可能会变成：CStash_initialize()、CStash_cleanup()。这样便能一定程度上减少这种冲突，但副作用便是使函数名看起来十分笨拙，而且越是复杂的函数，这样做越会使客户程序员混淆其真正意图。

　　怎样更好的避免这样的冲突？想想看，结构体中的变量标志与外部全局变量的标志是不会发生冲突的，即使它们看起来完全一样，那为何不把这种优点也发挥到函数上呢？嗯，把函数也一起放进结构体，这或许是个不错的选择。下面是把上面C库代码改写成使用这种结构后的栗子：

// CppLib.h
// C-like library converted to C++

struct Stash{
    int size;
    int quantity;
    int next;
    unsigned char* storage;
    //Functions
    void initialize(int size);
    void cleanup();
    int add(const void* element);
    void* fetch(int index);
    int count();
    void inflate(int increase);
} 

// C04:Cpplib.cpp
// C library converted to C++
// Declare structure and functions:
#include "Cpplib.h"
#include <iostream>
#include <cassert>
using namespace std;

const int increment = 100;

void Stash::initialize(int sz){
    size = sz;
    quantity = 0;
    storage = 0;
    next = 0;
}

int Stash::add(const void* element){
    if(next >= quantity)
        inflate(increment);
    int startBytes = next * size;
    unsigned char* e = (unsigned char*)element;
    for(int i = 0; i < size; i++)
        storage[startBytes + i] = e[i];
    next++;
    return(next -1);
}

void* Stash::fetch(int index){
    assert(0 <= index);
    if(index >= next)
        return 0;
    return &(storage[index * size]);
}

int Stash::count(){
    return next ;
}

void Stash::inflate(int increase){
    assert(increase > 0);
    int newQuantity = quantity + increase;
    int newBytes = newQuantity * size;
    int oldBytes = quantity * size;
    unsigned char* b = new unsigned char[newBytes];
    for(int i = 0; i < oldBytes; i++)
        b[i] = storage[i];
    delete [](storage);
    storage = b;
    quantity = newQuantity;
}

void Stash::cleanup(){
    if(storage != 0){
        cout << "freeing storage" << endl;
        delete []storage;
    }
}

　　这已经开始有一点点类的味道了，因为结构体中不仅包含了数据，还包含了行为，这样就已经具备了对象的两大特征，已经从C向C++迈出了第一步。在定义成员函数时，与C语言中有许多不同之处，比如使用作用域解析符::来表明是定义在哪个结构下的成员函数，在函数内部不再需要使用结构指针而是直接通过使用成员名来对成员进行操作。

　　下面是使用这个库的测试代码：

// CppLibTest.cpp
// CppLib
// Test the C++ library
#include "CppLib.h"
#include <fstream>
#include <iostream>
#include <string>
#include <cassert>
using namespace std;

int main(){
    Stash intStash, stringStash;
    int i;
    char* cp;
    ifstream in;
    string line;
    const int bufsize = 80;
    intStash.initialize(sizeof(int));
    for(i = 0; i < 100; i++)
        intStash.add(&i);
    for(i = 0; i < intStash.count(); i++)
        cout << "intStash.fetch(&intStash, " << i << ") = "
             << *(int*)intStash.fetch(i)
             << endl;
    stringStash.initialize(sizeof(char)* bufsize);
    in.open("CLib.cpp");
    assert(in);
    while(getline(in, line))
        stringStash.add(line.c_str());
    i = 0;
    while((cp = (char*)stringStash.fetch(i++)) != 0)
        cout << "stringStash.fetch(&stringStash, " << i << ") = "
             << cp << endl;
    intStash.cleanup();
    stringStash.cleanup();
}

　　从这里我们可以发现几个很明显的改变。第一，不需要再向每个函数传入一个结构体地址，事实上，编译器悄悄为我们做了这事。第二，函数都是通过类型名后加取成员符再加函数名来调用，可以用Stash来定义多个变量，而它们内部的函数实际上是一样的，只是一份代码的多个拷贝。

　　现在我们似乎已经很好的解决了命名空间这个问题，事实上，C++使用多个命名空间，这也是其具备很好扩展性的基础，想必大家对与std::不会感到陌生，这是标准C++库的命名空间，在不同命名空间使用相同的标识是不会发生冲突的。使用命名空间常用使用指令，如using namespace std，这样就可以直接使用cout 而不需要在前面再加上std::，因为使用指令已经告诉链接器在哪个命名空间查找。

　　那如果我们在结构体中定义的成员标志跟全局变量一样，而同时需要对它们操作该怎么办呢，下面时一个小栗子：

// Scoperes.cpp
// Global scope resolution
int a;
void f(){}

struct S {
    int a;
    void f();
};

void S::f(){
    ::f();//use the global func
    ::a++;//select the global a
    a--;  //the a at the struct
}

　　下面再说说头文件。关于头文件，在C语言学习的时候也许并不是十分明显和重要，因为它是可选的，而在C++中，头文件几乎是强制的。这样有很多的好处，第一是把所有函数信息，结构体信息放到头文件后方便链接器查找，第二是方便了客户程序员阅读和使用，在一个稍大一点的项目中，也许会多次使用到同一个头文件，这样就会带来多次声明的问题。例如，如果每个结构文件都包含了iostream这个库，那么就会面临多次重申输入输出流的危险。编译器认为重申明结构是一个错误，因为它还允许对不同的结构使用相同的名字，为了防止重复声明，我们需要对头文件做一点点处理。

　　这时需要用到预处理指令，#define,#undef,#ifdef,#ifndef,#endif。其含义通过名字也能大致猜测得到，下面是一段改进后的头文件代码：

#ifndef HEADER_FLAG
#define HEADER_FLAG
// type declaration
#endif

　　这样便能有效的防止多次声明的问题出现，因为只会在第一次声明时定义标志HEADER_FLAG，之后再引用这个头文件时，发现已经定义了这个标志，后面的代码将被忽略。

　　需要注意的一点是，不要在头文件中放使用指令，using namespace XXX，这样会破坏对指定命名空间的保护，因为头文件的引用通常在文件的最开始处，这样在整个文件中使用指令都会有效，这就意味着命名空间保护在使用该头文件的任何文件中消失。

　　再回到我们的结构体，现在结构体中已经有了数据和函数，但这还不够，因为有时候，我们并不希望其它客户程序员能够自由操作所有内部变量，因为这样可能更容易导致一些错误。这时候就需要用到C++中的访问控制符，public，private，protected。

　　使用public声明就意味着在其后的声明是可以被所有人访问的，public成员就如同一般的struct成员一样（可以理解为struct默认为public访问方式），而private则意味着，除了该类型的创建者和内部的成员函数之外，任何人都不能访问。这样在设计者和客户程序员中间建立了一道墙，只给客户程序员开放必要的接口。protected则是与private基本相似，只有一点不同，那就是继承的结构体可以访问protected成员。

　　这样做的好处一是能更好的确保数据安全，另一方面，也更好的将实现和接口分离开来，只要接口没有改变，内部实现不管怎样变，都不需要客户程序员再次改写代码，只需要重新编译一次就行了。有时还有这样的需求，想要其它不属于当前结构的一个成员函数访问当前结构中的数据，那该怎么办呢？这时候需要用到“友元”的概念。什么是“友元”呢，就是使用friend标志来声明一个外部的函数，以告知编译器“这是我这个类的朋友，他可以访问我所有成员的权限。”，这样这个友元便能访问其所有的成员和成员函数。下面是一个小栗子：

// Friend.cpp
// Friend allows special access
struct X;

struct Y {
    void f(X*);
};

struct X {
private:
    int i;
public:
    void initialize();
    friend void g(X*, int);
    friend void Y::f(X*);
    friend struct Z;
    friend void h();
};

void X::initialize(){
    i = 0;
}

void g(X* x, int i){
    x->i = i;
}

void Y::f(X* x){
    x->i = 47;
}

struct Z {
private:
    int j;
public:
    void initialize();
    void g(X* x);
};
void Z::initialize(){
    j = 99;
}

void Z::g(X* x){
    x->i += j;
}

void h(){
    X x;
    x.i = 100;
}

int main(){
    X x;
    Z z;
    z.g(&x);
}

　　struct加上函数加上访问控制加上友元，便已经演变出了类的模型。在最初的面向对象语言中，关键字class被用来描述一个新的数据类型，显然也启发了Stroustrup在C++中用同样的关键字，来强调这是整个语言的关键所在，新的数据类型并不是只在C的struct中加上函数，还包括很多其他的特性，这当然需要一个新的关键字。

　　有着相似定义的class和struct的唯一区别在于，class默认访问方式为private，而struct的默认访问方式为public。

　　最后，还有一点点补充说明的情况。当我们想隐藏更多关于private成员的信息时（比如我们在开发一个加密库，为了防止有人不择手段使用各种指针来访问私有成员），我们可以更好的封装，将内部结构体也封装起来，仅提供一个使用的指针，也可以叫住句柄。下面是一个小栗子：

// Handle.h
// Handle classes
#ifndef HANDLE_H
#define HANDLE_H

class Handle {
    struct Cheshire;
    Cheshire* smile;
public:
    void initialize();
    void cleanup();
    int read();
    void change(int);
};

#endif // HANDLE_H 

// Handle.cpp
// Handle implementation
#include "Handle.h"

// Define Handle's implementation
struct Handle::Cheshire{
    int i;
};

void Handle::initialize(){
    smile = new Cheshire;
    smile->i = 0;
}

void Handle::cleanup(){
    delete smile;
}

int Handle::read(){
    return smile->i;
}

void Handle::change(int x){
    smile->i = x;
}

　　在头文件中仅包含公共接口和一个单指针，该指针指向一个没有完全定义的类，而将类的定义放到实现文件中，这样就能将结构更好的隐藏起来。这样做还有另一个好处，那便是减少重复编译，试想一下，如果开发一个大型项目，难免会有内部实现的改动，而这样就会导致所有引用该头文件的文件都需要重新编译，十分不方便。使用了句柄这种方式后，只要定义没有改变，结构体无论怎样改变，只需要重新编译定义文件即可，大大的节省了时间。

　　至此，一个类的成长历程已经说了一大块了，之后的继承多态和重载，以后的文章再做说明。