C++中的类

C＋＋中的类组成：类头＋类体

class Screen { /* ... */ };
class Screen { /* ... */ } myScreen, yourScreen;

两种表示方法都以分号结尾。

类的引用：

class Screen scr1;

Screen src2;

数据成员：

#include <string>
class Screen {
string _screen;
string::size_type _cursor; // string::size 是数据类型，该类型是一种存放sting数据成员的引索值的可移植类型，是int的严格形式。这里表示当前屏幕Screen 位置
short _height;
short _width;
};

成员函数：

class Screen {
public:
    void home();
    void move( int, int );
    char get();
    char get( int, int );
    bool checkRange( int, int );
};

成员函数的定义也可以被放在类体内。例如，
class Screen {
public:
    void home() {

         _cursor = 0;

    }
    char get() {

         return _screen[_cursor];

    }
};

成员函数与普通函数的区别：

1。成员函数类域外不可见，访问方法：

ptrScreen->home();
myScreen.home();

2。成员函数可以访问该类中的私有和公有的成员。

3。成员函数可以是重载函数，但是只能重载该类中的函数。如，

class Screen {
public:
     char get() { return _screen[_cursor]; }
     char get( int, int );
};

成员限定符：

#include <iostream>
#include "Screen.h"

bool Screen::checkRange( int row, int col )// 成员函数名用 Screen:: 限定修饰
{
     if ( row < 1 || row > _height || col < 1 || col > _widt h ) {
          cerr << "Screen coordinates ( "<< row << ", " << col << " ) out of bounds./n";
          return false;
     }
     return true;
}

这里的函数checkRange( int row, int col )

如果不是在类定义之前，则是一个非inline函数。在这种情况下，可以在函数名前加上关键字inline或者在类内部函数声明时加inline使其变为内联的。如果在类声明之后，则默认是内联函数。

const成员函数：

const成员函数表明该函数不修改类对象。如，

class Screen {
public:
     char get() const { return _screen[_cursor]; }
}

只有被声明为const 的成员函数才能被一个const 类对象调用。

关键字const 被放在成员函数的参数表和函数体之间。

对于在类体之外定义的const 成员函数，我们必须在它的定义和声明中同时指定关键字const。 例如，

class Screen {
public:
     bool isEqual( char ch ) const;
private:
     string::size_type _cursor;
     string _screen;
};
bool Screen::isEqual( char ch ) const
{
     return ch == _screen[_cursor];
}

如果该类含有指针，那么在const 成员函数中就能修改指针所指的对象。编译器不会
把这种修改检测为错误：

#include <cstring>
class Text {
public:
     void bad( const string &parm ) const;
private:
     char *_text;
};
void Text::bad( const string &parm ) const
{
     _text = parm.c_str(); // 错误: 不能修改 _text
     for ( int ix = 0; ix < parm.size(); ++ix )
          _text[ix] = parm[ix]; // 不好的风格, 但不是错误的
}

构造函数和析构函数是两个例外，即使构造函数和析构函数不是const 成员函数，const
类对象也可以调用它们。当构造函数执行结束、类对象已经被初始化时，类对象的常量性就
被建立起来了。析构函数一被调用，常量性就消失。所以一个const 类对象从构造完成时
刻到析构开始时刻这段时间内被认为是const。

volatile成员函数：

对于一个volatile 类对象，只有volatile
成员函数构造函数和析构函数可以被调用：

class Screen {
public:
     char poll() volatile;

};
char Screen::poll() volatile { ... }