// 对继承的深刻了解

#include <iostream>

using namespace std;

// 定义类
class Animal
{
public:
    Animal(int x, int y)                        // 定义构造函数：修改  将无参改为有参
    {
        cout << "Animal construct" << endl;
    }
    ~Animal()                                    // 定义析构函数
    {
        cout << "Animal deconstruct" << endl;
    }
    void eat()
    {
        cout << "Animal eat" << endl;
    }
private:
    void sleep()
    {
        cout << "Animal sleep" << endl;
    }
protected:
    void speak()
    {
        cout << "Animal speak" << endl;
    }
};                                                // 注意;号不要忘

class Fish : public Animal                        // 继承，使得代码重用
{
public:
    // Fish()
    Fish():Animal(10, 10),a(1)                    // 修改后的子类的构造函数：在子类中，向基类带参数的构造函数传递参数的一种方式;后加对常量的初始化
    {
        cout << "Fish construct    "<< a << endl;
    }
    ~Fish()
    {
        cout << "Fish deconstruct" << endl;
    }
private:
    const int a;
};

void main()
{
    Animal al(5, 6);
    al.eat();

    Fish fh;
    fh.eat();
}

/*
小结：
    1、没有父类就没有子类，所以都是从父到子的（如果是按这个顺序的话）
    2、构造函数调用了父类的，还在调用子类的
    3、将父类的构造函数从无参该为有参，则在子类中，需对子类的构造函数进行修改
        修改方法见上，一个无参一个有参，则调用的顺序为：子类构造函数（但不进行函数体就转向调用基类的“默认”构造函数）、基类构造函数、子类构造函数
        默认：当声明基类对象时，要从基类先调用父类的  默认构造函数  而现在父类中没有 不带参数的  构造函数  ，所以在
              子类中，必需对构造函数进行修改，见原程序

    4、默认的构造函数就是不带参数的构造函数
*/

函数的覆盖

    函数的覆盖是发生在父类与子类之间的。

// 对继承的深刻了解，增加了函数的覆盖功能

#include <iostream>

using namespace std;

// 定义类
class Animal
{
public:
    Animal(int x, int y)                        // 定义构造函数：修改  将无参改为有参
    {
//        cout << "Animal construct" << endl;
    }
    ~Animal()                                    // 定义析构函数
    {
//        cout << "Animal deconstruct" << endl;
    }
    void eat()
    {
        cout << "Animal eat" << endl;
    }
private:
    void sleep()
    {
        cout << "Animal sleep" << endl;
    }
protected:
    void speak()
    {
        cout << "Animal speak" << endl;
    }
};                                                // 注意;号不要忘

class Fish : public Animal                        // 继承，使得代码重用
{
public:
    // Fish()
    Fish():Animal(10, 10),a(1)                    // 修改后的子类的构造函数：在子类中，向基类带参数的构造函数传递参数的一种方式;后加对常量的初始化
    {
//        cout << "Fish construct    "<< a << endl;
    }
    ~Fish()
    {
//        cout << "Fish deconstruct" << endl;
    }

    // 增加代码
    void eat()                                    // 在子类中，新增Fish的吃的特性。此时会发生函数的覆盖，将屏蔽父类中在eat()函数
    {
        Animal::eat();                            // 但此时我不想完全屏蔽父类的eat的特性，则通过作用域标识符来调用父类的eat函数
        cout << "Fish eat" << endl;
    }
private:
    const int a;
};

void main()
{
    Animal al(5, 6);
    al.eat();

    Fish fh;
    fh.eat();
}

/*
小结：
    1、没有父类就没有子类，所以都是从父到子的（如果是按这个顺序的话）
    2、构造函数调用了父类的，还在调用子类的
    3、将父类的构造函数从无参该为有参，则在子类中，需对子类的构造函数进行修改
        修改方法见上，一个无参一个有参，则调用的顺序为：子类构造函数（但不进行函数体就转向调用基类的“默认”构造函数）、基类构造函数、子类构造函数
        默认：当声明基类对象时，要从基类先调用父类的  默认构造函数  而现在父类中没有 不带参数的  构造函数  ，所以在
              子类中，必需对构造函数进行修改，见原程序

    4、默认的构造函数就是不带参数的构造函数
*/

多态性

   当C++编译器在编译的时候，发现Animal类的breathe()函数是虚函数，这个时候C++就会采用迟绑定（late binding）的技术，

在运行时，依据对象的类型（在程序中，我们传递的Fish类对象的地址）来确认调用的哪一个函数，这种能力就做C++的多态性。

抽象类不能实例化对象

抽象类不能实例化对象

引用就是变量的一个别名，在定义时，就必需初始化；

eg: int a;  int &b;  b = a;   错
    int a;  int &b = a;        yes ，你答对了

对引用的操作，就是对该引用变量的操作

引用  和  指针  的区别

    从内存模型上去区分：
        引用不需要另辟内存空间；而指针则需要，用来存放地址

在头文件中，使用预编译的好处：

    可以在头文件的相互包含中，避免出现重复定义的情况发生！

2011年5月15日12:22:46

龚建伟Visual.C._Turbo.C串口通信编程实践

体验Windows 环境下的Visual C++ 串口通信编程

1、建立应用工程
    建立基于对话框的MFC应用程序
2、添加MSComm控件
3、初始化串口：设置MSComm控件属性
4、添加串口事件消息处理函数
5、发送数据