使用VC6.0编写上位机串口程序

第一步：了解了下串口调试助手的基本构架

主要由三个部分组成 ：串口设置区、接收显示区和发送输入区

具体的，自己可以下个串口助手，自己玩玩，就OK

今天学习编写了 HelloCPP  和 HelloMFC ,大有收获！

唐三藏西天取经，沿途要收拾妖怪只是为了开路，而不是要将全世界的妖怪全都消灭掉！

一个有关数组问题的举例

/*
    说明：如何获取别人的而自己又不知道的数组属性
*/

#include <iostream>

using namespace std;

int main()
{
    int arr[10]={0};
    int count;

    count = sizeof(arr)/sizeof(int);            // 先获取整个数组的大小，再获取每个元素的大小
    cout << "The number of array are : " << count << endl;
    cin.get();

    return 0;
}

随心所欲所择 =====  条件语句

2011年5月12日8:23:08
    温故C++  ing。。。。。。。

C++中   this 指针指向对象本身~~~

小程序，大问题

#include <iostream>

using namespace std;

class Point
{
public:
    int x;
    int y;

    Point()        // 构造函数，初始化成员变量
    {
        x = 0;
        y = 1;
    }
    Point(int a, int b)
    {
        x = a;
        y = b;
    }
    ~Point()    // 释放内存空间
    {
    }

    void output()
    {
        cout << x << endl << y << endl;
    }
    void output(int x, int y)
    {
        this->x = x;        // 当形参变量和类的对象变量同名时，存在一个作用域的问题
        this->y = y;        // 所以引入this指针来加以区分，说明this指向的x是类对象变量中的x
    }
};

void main()
{
    Point pt(5, 5);        // 定义一个对象
    pt.output(3, 3);
    pt.output();        // 输出结果为 3 3，若将void output(int x , int y)函数体中的this指针去掉，则结果为 5 5
}

类的继承
   
   在C++中，给我们提供了一种重要的机制，就是继承。 理解继承是理解面向对象程序设计的关键。

// 对继承的深刻了解

#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、默认的构造函数就是不带参数的构造函数
*/

抽象类不能实例化对象

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

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

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

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

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

书上传不了，给大家一个下载地址

http://wenku.baidu.com/view/e581ef4dfe4733687e21aaa5.html

2011年5月22日17:04:32
    来打个酱油

10楼得这个程序与“面向对象”有一点联系吗？？？