C++核心编程学习

#ifndef __MYCLASS_H_
#define __MYCLASS_H_

#include<iostream>
#include<string>
using namespace std;

class Complex{
public:
    Complex(int _m_rel = 0, int _m_vir = 0) :m_rel(_m_rel), m_vir(_m_vir){}
    //成员函数重载
    Complex& operator +=(const Complex& c1);
    Complex& operator -=(const Complex& c1);
    Complex& operator++(); //前置++ ++Complex，返回引用
    Complex operator++(int); //后置++,返回值
    //赋值运算符的重载，如果涉及到堆区内存，，要先释放原来的堆区空间，，再来分配新赋值的空间，防止浅拷贝

    //函数调用运算符重载；调用的时候直接类名(字符串)，或者类对象(字符串)
    void operator()(string test){
        cout << test << endl;
    }
    int getRel()const{return m_rel;}
    int getVir()const{return m_vir;}
    void test_print();
private:
    int m_rel, m_vir;
    friend Complex operator +(const Complex& c1, const Complex& c2);
    friend Complex operator -(const Complex& c1, const Complex& c2);
    friend Complex operator *(const Complex& c1, const Complex& c2);
    friend Complex operator /(const Complex& c1, const Complex& c2);
    friend bool operator == (const Complex& c1, const Complex& c2);
    friend bool operator != (const Complex& c1, const Complex& c2);
    friend ostream& operator <<(ostream& os, const Complex& c1);
    friend istream& operator >>(istream& is, const Complex& c1);

};

inline Complex operator +(const Complex& c1, const Complex& c2){
    return Complex(c1.m_rel + c2.m_rel, c1.m_vir + c2.m_vir);
}

inline Complex operator -(const Complex& c1, const Complex& c2){
    return Complex(c1.m_rel - c2.m_rel, c1.m_vir - c2.m_vir);
}

inline Complex operator *(const Complex& c1, const Complex& c2){
    return Complex(c1.m_rel * c2.m_rel, c1.m_vir * c2.m_vir);
}

inline Complex operator /(const Complex& c1, const Complex& c2){
    return Complex(c1.m_rel / c2.m_rel, c1.m_vir / c2.m_vir);
}

inline bool operator == (const Complex& c1, const Complex& c2){
    if (c1.m_rel == c2.m_rel && c1.m_vir == c2.m_vir){
        return true;
    }
    return false;
}

inline bool operator != (const Complex& c1, const Complex& c2){
    if (c1.m_rel != c2.m_rel || c1.m_vir != c2.m_vir){
        return true;
    }
    return false;
}

inline Complex& Complex::operator += (const Complex& c1){
    this->m_rel += c1.m_rel;
    this->m_vir += c1.m_vir;
    return *this;
}

inline Complex& Complex::operator -= (const Complex& c1){
    this->m_rel -= c1.m_rel;
    this->m_vir -= c1.m_vir;
    return *this;
}

inline ostream& operator <<(ostream& os, const Complex& c1){
    return os << "[" << c1.m_rel << "," << c1.m_vir << "]" << endl;
}

inline istream& operator >> (istream& is, const Complex& c1){
    return is >> c1.m_rel >> c1.m_vir;
}
inline Complex& Complex::operator ++(){
    ++this->m_rel;
    ++this->m_vir;
    return *this;
}

inline Complex Complex::operator ++(int){
    Complex old = *this;
    this->m_rel ++;
    this->m_vir ++;
    return old;
}



#endif

#include<iostream>
using namespace std;

class Animal{
public:
    void doSpeak(){
        cout << "动物在说话" << endl;
    }
};

class Cat : public Animal{
public:
    void doSpeak(){
        cout << "小猫在说话" << endl;
    }
};

class Dog : public Animal{
public:
    void doSpeak(){
        cout << "小狗在说话" << endl;
    }
};

void doSpeak(Animal & animal){
    animal.doSpeak();
}

void test1(){
    cout << "sizeof(Animal) = " << sizeof(Animal) << endl;  

int main(){
    Cat cat;
    Dog dog;
    doSpeak(cat);
    doSpeak(dog);
    test1();
    return 0;
}

//以上代码的输出程序很明显：因为这是静态动态，地址在编译阶段就已经确定，所以使用animal的类成员函数，
//调用的肯定都是animal类里的doSpeak函数，所以输出两个动物在说话;;而且此时animal类的大小为1;

//如果在animal类里面的doSpeak的返回值前加入一个virtual，那就成了动态多态：
//虽然使用的还是animal.doSpeak()，但是地址是在运行时绑定的，所以这个绑定的地址其实就是实参这里new的空间地址,
//所以就是new什么输出什么，所以输出一个小猫在说话，一个小狗在说话
//此时animal类的大小是4；虽然Animal类里无非静态成员变量，但是加了virtual后，，就会多一个指针
                               // （vfptr:虚函数指针）
                        //指向vftable（记录虚函数地址）

#include<iostream>
using namespace std;

class AbstaractDrink{
public:
    virtual void Boil() = 0; //煮水
    virtual void Brew() = 0; //冲泡
    virtual void PourInCup() = 0; //倒入杯中
    virtual void PutSomeThing() = 0;//加入辅料

    void makeDrink(){
        Boil();
        Brew();
        PourInCup();
        PutSomeThing();
    }
};

class Coffee : public AbstaractDrink{
public:
    void Boil(){
        cout << "煮农夫山泉" << endl;
    }

    void Brew(){
        cout << "冲泡咖啡" << endl;
    }

    void PourInCup(){
        cout << "倒入咖啡杯中" << endl;
    }

    void PutSomeThing(){
        cout << "加入牛奶 " << endl;
    }
};

class Tea : public AbstaractDrink{
public:
    void Boil(){
        cout << "煮百岁山" << endl;
    }

    void Brew(){
        cout << "冲泡茶叶" << endl;
    }

    void PourInCup(){
        cout << "倒入茶杯中" << endl;
    }

    void PutSomeThing(){
        cout << "加入枸杞 " << endl;
    }
};

void doWork(AbstaractDrink *abs){
    abs->makeDrink();
    delete abs;
}

int main(){
       cout << "-----制作咖啡------" << endl;
       doWork(new Coffee);
       cout << "-----制作茶叶------" << endl;
       doWork(new Tea);
       return 0;
}