高级编程语言复习(Cpp/API/MFC)

• 类是对象的抽象类型
• 对象是类的具体实例
• 类和对象的关系是一种数据类型与变量的关系

对象的创建
* 直接方式
* 间接方式
* new创建
* delete消除

类中的成员函数对该类的所有对象只有一个拷贝。
编译时不会出错的是

class Point
{
    public: Point(double x, double y);
    ...
}
A Point pt1; //只有未定义狗早函数时才会自动生成一个默认构造函数
B Point pt2.Point(2, 2); //不能显式的调用构造函数
C Point pt3 = new Point(2, 2); //类型不匹配
D Point pt4(4, 4), *pt5 = &pt4;

成员函数加上const修饰符，
* 用于只获取对象状态的成员函数
* 用于对常量对象进行操作

友元
* 不对称性
* 不具有传递性
* 数据保护与数据访问效率的一种折衷方案

设计一个类

class Stack
{
public:
    Stack(int stacksize = 10);
    ~Stack();
    void push(const int x);
    int pop();
    ...
private:
    int count;
    int size;
    int *data;
}

Stack::Stack(int stacksize)
{
    if(stacksize > 0)
    {
        size = stacksize;
        stack = new int[size];
        count = 0;
        for(int i=0; i<size; i++)
        {
            data[i] = 0;
        }
    }
    else
    {
        data = 0;
        size = 0;
    }
}
Stack::~Stack()
{
    delete[] data;
}

void Stack::push(int x)
{
    if(count >= size)
    {
        count << "栈溢出";
        return;
    }
    else
    {
        data[count] = x;
        count ++;
    }
}

int Stack::pop()
{
    if(count <= 0)
    {
        cout << "栈为空";
        return -1;
    }
    count --;
    return data[count];
}

int main()
{
    Stack s1;
    s1.push(1);
    s1.pop();
    return 0;
}

将stack.cpp编译为静态链接库，可以实现封装与信息隐藏。

操作符重载

继承–派生类
* 单继承
* 多继承

class B: pulic A
{
    int z;
public:
    void f();
    void h()
    void h()
    {
        f();
        A::f();
    };
    B b;
    b.f();
    b.A::f();   
}

定义派生类时一定要已有基类的定义。
继承方式

如果一个类D既有基类B、又有成员对象类M，则
* 创建D类对象时，构造函数执行次序为B->M->D
* D类对象消亡时，析构函数执行次序为D->M->B

多态性是指一组具有相同基本语义的方法能在同一接口下为不同的对象服务。
* 编译时的多态性：函数重载，模板实现，静态绑定
* 运行时的多态：虚函数，动态绑定

静态绑定
C++默认情况下为静态绑定

class A
{
public:
    void f();
};
class B: public A
{
public:
    void f();
}

即采用A::f()

虚函数-动态绑定

class A
{
public:
    virtual void f();
};
class B: public A
{
public:
    void f();
}

调用A::f()或者B::f()，不确定，视情况而定。
只用通过引用或指针来访问虚函数才进行动态绑定。
特例：通过类名受限来访问虚函数采用静态绑定。

纯虚函数和抽象类
纯虚函数：只给出函数声明而没有给出实现，

class A
{
public:
    virtual int f() = 0; //纯虚函数
};

包含纯虚函数的类称为抽象类
抽象类不能用于创建对象。
纯虚函数在派生类中可以多态地定义具体的函数体。
如果一个类至少有一个纯虚函数，那么它就是抽象类。
抽象类只能用作其他类的基类，抽象类自身无法实例化。

派生类如果没有全部定义纯虚函数的操作，继承类部分纯虚函数，那么它还是抽象类。

多继承
基类以”,”分隔

虚基类

//class x1: virtual public x{}
class x{public: int a;};
class X1: virtual public X{public: int b1;};
class X2: virtual public X{public: int b2;};
class Y: public X1, public X2{public: float d;};
Y obj;
obj.a = 5;