孙鑫MFC笔记教程(2)--C++经典语法与应用

 

掌握C++

1，优点：封装性，继承性，多态性。

2，结构体

//struct Point

class Point

{

public:

    int x;

    int y;

    void output()

    {

        cout<<pt.x<<endl<<pt.y<<endl;

    }

};

void main()

{

    Point pt;

    pt.x=5;

    pt.y=5;

    //cout<<pt.x<<endl<<pt.y<<endl;

    pt.output();

}

输入输出流：cin,cout,cerr

cin>>：输入操作

cout<<：输出操作

cerr<<：标准错误输出

endl：end of line 换行

#include <iostream.h> ：输入输出头文件

结构体中可以有函数。

结构体是特殊的类，与类的区别在于访问控制。结构体缺省情况下是public,而类缺省情况下是private。

public：可以在类的外部可以访问。

private：不可以类的外部访问。

3，类是抽象出来属性的，对象是有具体属性的实实在在存在的。类的实例就是一个对象。实例化一个对象就是产生一个类的对象。

4，面向过程，面向对象

5,构造函数

class Point

{

public:

    int x;

/*    int y;

    void init()

    {

        x=0;

        y=0;

    } */

    Point()

    {

        x=0;

        y-0;

    }

    Point(int a,int b)

    {

        x=a;

        y=b;

    }

    void output()

    {

        cout<<pt.x<<endl<<pt.y<<endl;

    }

    void output(int x,int y)

    {

        x=x;

        y=y;   

    }

};

void main()

{

    Point pt(3,3);

    pt.output(5,5);

    //pt.init();

    //pt.x=5;

    //pt.y=5;

    //cout<<pt.x<<endl<<pt.y<<endl;

    pt.output();

}

没有对X，Y设定值，所以输出随即的数。

用init()函数对X,Y进行初始化。

构造函数，与类名一致，没有返回值。point()。调用PT时候自动调用构造函数，进行X，Y赋值。

构造函数最重要的作用是创建对象本身，即赋予一定内存空间。每一个类都必须有一个构造函数，但是如果类没有提供构造函数系统会默认提供一个不带参数的构造函数。只负责创建对象。如果定义了一个构造函数，系统就不会再提供。

6，析构函数

~Point，带取反符号的类名。当对象生命周期结束时调用析构函数进行内存的释放。构造函数和析构函数是提供给系统来调整内存。析构函数不带参数，没有返回值。

7，函数的重载

Point(int a,int b)

{

    x=a;

    y=b;

}

根据调用的格式进行匹配选择对应的行数。

比如：

调用Point pt时选

Point()

    {

        x=0;

        y-0;

    }

调用Point pt(3,3)时候

Point(int a,int b)

    {

        x=a;

        y=b;

    }

两种情况：

第一种：返回值不一样，调用pt.output时产生混淆，不能构成函数的重载。

void output();

int output();

第二种：调用pt.output(2)是产生混淆，不知道是output(2,5)还是output(2)，所以不能构成函数重载。

void output(int a,int b=5);

void output(int a)

8，this指针

output(int x,int y)

{

    x=x;

    y=y;

}

没有对外部成员变量X，Y进行赋值，只是对形参 int x,int y进行了操作。

output(int x,int y)

{

    this->x=x;

    this->y=y;

}

this指针指向对象本身。对于类实例化的对象的。所以需要先实例化一个对象后才会产生this指针生成。main函数中先实例化一个对象。

9，类的继承

#include <iostream.h>

class Animal

{

public:

    void eat()

    {

        cout<<"animal eat"<<endl;

    }

protected:

    void sleep()

    {

        cout<<"animal sleep"<<endl;

    }

private:

    void breathe()

    {

        cout<<"animal breathe"<<endl;

    }

};

class Fish : public Animal

{

    void test()

    {

        sleep();

        breathe();

    }

};

void main()

{

    Animal an;

    an.eat();

    Fish fh;

    fh.sleep();

}

Fish 派生类也可以叫子类

Animal 基类也可以叫父类

(访问控制)protected:子类可以访问，但是外部不能访问。

(访问控制)private:子类也不能访问

Public方式继承

private方式继承

protected方式继承

10，类的继承中构造函数

#include <iostream.h>

class Animal

{

public:

    Animal(int height,int weight)

    {

        cout<<"animal construct"<<endl;

    }

    ~Animal()

    {

        cout<<"nimal deconstruct"<<endl;

    }

    void eat()

    {

        cout<<"animal eat"<<endl;

    }

    void sleep()

    {

        cout<<"animal sleep"<<endl;

    }

    virtual void breathe()

    {

        cout<<"animal breathe"<<endl;

    }

};

class Fish : public Animal

{

    Fish():Animal(400,300):a(1)

    {

        cout<<"fish contruct"<<endl;

    }

    ~Fish()

    {

        cout<<"fish deconstruct"<<endl;

    }

    void breathe()

    {

        //Animal::breathe();

        cout<<"fish babool"<<endl;

    }

private:

    const int a;

};

void fh(Animal *pAn)   //全局函数

{

    pAn->breathe();

}

void main()

{

    Fish fh;

    Animal *pAn;

    pAn=&fh;

    fn(pAn);

}

基类先构造，在构造子类。

子类先析构，基类再析构。

先构造Animal构造函数是找不到匹配的构造函数，即Animal(int height,int weight)没有能赋予参数。所以构造Fash时候给带参数Animal传入400,300参数，成功构造Animal，再构造Fish。

对于常量可以使用Fish():Animal(400,300):a(1)方式

11，函数的覆盖：在父类和子类当中产生，函数的重载在一个类当中产生。

用子类中Animal::breathe();方式实现父类和子类两个种方法一起实现。

12，类型的转换

char ch; 一个字节

int i;   四个字节

ch=(char)i; 会丢失3个字节

i=(int)ch;  允许。

对象之间也可以转换。主要看内存模型

13，多态性，虚函数。

用virtual定义基类一个函数时候：子类有的就调用子类，子类没有就调用父类的。没有VIRTUAL定义时都用基类的。

14，纯虚函数

基类中不太好确定函数的形式用 virtual void breathe()=0定义。在子类中再确切定义。

15，引用

int a=6;

int &b=a;  //&符有特殊表示，在这里表示引用。别的地方表示地址。

b=5;

a就等于5，将a绑定在b上。

要与指针变量区分两种情况：

第一种,引用不需要内存地址，给a取了个别名b。a和b用一块内存地址0012:FF7C

int a=5;

int &b=a;

第二种,指针变量需要内存。p等于a的内存地址0012:FF7C,而P得内存地址为0012：FF78

int a=5;

int *p=&a;

16,在全局函数中定义类内部的函数用::符号。

比如函数

void Animal::eat

{

}

主要用于把定义在头文件中单独放开。在源文件中对此头文件中类的函数进行定义

17，头文件

#include "Animal.h" 直接在当前目录下查找，不确定时候用""，他会在查找玩当前目录后去系统目录查找。

#include <iostream.h> 从系统目录下查找

18，预编译指令

#ifndef XXXX       //查看XXXX是否定义

#define xxxx 1    //如果没有定义就赋予XXXX值 1

class Point

{

};

#endif            //如果定义了就下一步

#ifndef XXXX              //查看XXXX是否定义

#define XXXX  2          //如果没有定义就赋予值 2

class Point

{

};

#endif               //如果定义了就进行下一步

void main()

{

    Point pt;

}

 

源文档 <http://amuristudio.appspot.com/?p=62002>

 

 

1, c语言中，结构体struct中不能包括函数的，而在C++中struct中可以包括函数。

2，C++中结构体和类可以通用，区别主要表现在访问控制方面：struct中默认是public，而 class中默认的是private。

3，构造函数最重要的作用是创建对象的本身，C++中每个类可以拥有多个构造函数，但必须至少有一个构造函数，当一个类中没有显式提供任何构造函数，C++编辑器自动提供一个默认的不带参数的构造函数，这个默认的构造函数只负责构造对象，不做任何初始化工作。但在一个类中只要自己定义一个构造函数，不管带参不带参，编辑器不再提供默认的不带参的构造函数了。构造函数没有返回值。

4,析构函数当一个对象生命周期结束时候被调用来回收对象占用的内存空间。一个类只需有一个析构函数。析构函数没有返回值也不的带参数。

5，析构函数的作用与构造函数相反，对象超出起作用范围对应的内存空间被系统收回，或被程序用delete删除的时候，对象的析构函数被调用。

6，函数的重载条件：函数的参数类型、个数不同，才能构成函数的重载。重载是发生在同一个类中。

7，类是抽象的，不占用具体物理内存，只有对象是实例化的，是占用具体物理内存的。

8，this指针是隐含指针，指向对象本身（this指针不是指向类的），代表了对象的地址。所有的对象调用的成员函数都是同一代码段，但每个对象都有自己的数据成员。当对象通过调用它的成员函数来访问它的数据成员的时候，成员函数除了接收实参外，还接收了对象的地址，这个地址被一个隐藏的形参this所获取，通过这个this指针可以访问对象的数据成员和成员函数。

9，对象中public属性的成员在外部和子类中都可以被访问；protected属性的成员在外部不能被访问，在子类中是可以访问的；private属性在子类中和外部都不能被访问。

10，类的继承访问特性：（public,protected,private)

 a）基类中private属性成员，子类无论采用那种继承方式都不能访问。

 b）采用public继承，基类中的public,protected属性的成员访问特性在子类中仍然保持一致。

 c）采用protected继承，基类中的public,protected属性成员访问特性在子类中变为protected.

 d）采用provate继承，基类中的public,protected属性成员访问特性在子类中变为provate.

11，子类和基类的构造函数或析构函数调用顺序：

 当调用子类的构造函数时候先调用基类的构造函数（如果没有指明，则调用基类却省那个不带参数的构造函数；如果要指明则在子类构造函数名后加":基类名(参数)"）。析构函数则相反，先调用子类析构函数，后调用基类的析构函数。

12，函数的覆盖：

 函数的覆盖是发生在发生父类和子类之间的。（函数的重载是发生在同一个类中）

 当子类中重写了父类的某些成员函数后，子类中的成员函数覆盖了父类的对应同名成员函数。

13，用父类指针访问子类对象成员时候，只能访问子类从父类继承来的那部分。（这时候外部不可以访问父类中保护和私有的部分，子类中不可访问父类私有部分。）

14，多态性：在基类的的成员函数前加virturl变成虚函数，当用子类对象调用该功能的成员函数时候，子类有的就调用子类的，子类没有的就调用基类的。

 当C++编译器在编译的时候，发现被调用的成员函数在基类中定义的是虚函数，这个时候C++就会采用迟绑定技术（late binding)，在运行的时候，依据对象的类型来确定调用的哪个函数，子类有调用子类的，子类没有的就调用基类的。

 如果基类中的成员函数不是虚函数，则这时候的绑定是早期绑定，在编译的时候就已经确定该调用哪个函数。

15，纯虚函数：在类中定义时 eg: virtual void f1()=0;

 纯虚函数没有函数体，含有纯虚函数的类叫做抽象类，抽象类不能实例化对象。当子类从抽象类的基类中派生出来时候，如果没有实现基类中的纯虚函数，则子类也是个抽象类，也不能实例化对象。

 纯虚函数被标名为不具体实现的虚成员函数，纯虚函数可以让类只具有操作的名称而不具有具体的操作的内容，让派生类在继承的时候再给出具体的定义。如果派生类没有给出基类的纯虚函数的具体定义的时候，派生类也为一个抽象类，也不能实例化对象。

16，引用：变量的别名。引用需要在定义的时候用一变量或对象初始化自己。引用一旦在定义的时候初始化，就维系在一个特定的变量或对象上。

 引用不占用物理内存（与定义引用的目标共用同一内存）。指针变量需要占用物理内存，用来存储地址。

1, c语言中，结构体struct中不能包括函数的，而在C++中struct中可以包括函数。

2，C++中结构体和类可以通用，区别主要表现在访问控制方面：struct中默认是public，而 class中默认的是private。

3，构造函数最重要的作用是创建对象的本身，C++中每个类可以拥有多个构造函数，但必须至少有一个构造函数，当一个类中没有显式提供任何构造函数，C++编辑器自动提供一个默认的不带参数的构造函数，这个默认的构造函数只负责构造对象，不做任何初始化工作。但在一个类中只要自己定义一个构造函数，不管带参不带参，编辑器不再提供默认的不带参的构造函数了。构造函数没有返回值。

4,析构函数当一个对象生命周期结束时候被调用来回收对象占用的内存空间。一个类只需有一个析构函数。析构函数没有返回值也不的带参数。

5，析构函数的作用与构造函数相反，对象超出起作用范围对应的内存空间被系统收回，或被程序用delete删除的时候，对象的析构函数被调用。

6，函数的重载条件：函数的参数类型、个数不同，才能构成函数的重载。重载是发生在同一个类中。

7，类是抽象的，不占用具体物理内存，只有对象是实例化的，是占用具体物理内存的。

8，this指针是隐含指针，指向对象本身（this指针不是指向类的），代表了对象的地址。所有的对象调用的成员函数都是同一代码段，但每个对象都有自己的数据成员。当对象通过调用它的成员函数来访问它的数据成员的时候，成员函数除了接收实参外，还接收了对象的地址，这个地址被一个隐藏的形参this所获取，通过这个this指针可以访问对象的数据成员和成员函数。

9，对象中public属性的成员在外部和子类中都可以被访问；protected属性的成员在外部不能被访问，在子类中是可以访问的；private属性在子类中和外部都不能被访问。

10，类的继承访问特性：（public,protected,private)

 a）基类中private属性成员，子类无论采用那种继承方式都不能访问。

 b）采用public继承，基类中的public,protected属性的成员访问特性在子类中仍然保持一致。

 c）采用protected继承，基类中的public,protected属性成员访问特性在子类中变为protected.

 d）采用provate继承，基类中的public,protected属性成员访问特性在子类中变为provate.

11，子类和基类的构造函数或析构函数调用顺序：

 当调用子类的构造函数时候先调用基类的构造函数（如果没有指明，则调用基类却省那个不带参数的构造函数；如果要指明则在子类构造函数名后加":基类名(参数)"）。析构函数则相反，先调用子类析构函数，后调用基类的析构函数。

12，函数的覆盖：

 函数的覆盖是发生在发生父类和子类之间的。（函数的重载是发生在同一个类中）

 当子类中重写了父类的某些成员函数后，子类中的成员函数覆盖了父类的对应同名成员函数。

13，用父类指针访问子类对象成员时候，只能访问子类从父类继承来的那部分。（这时候外部不可以访问父类中保护和私有的部分，子类中不可访问父类私有部分。）

14，多态性：在基类的的成员函数前加virturl变成虚函数，当用子类对象调用该功能的成员函数时候，子类有的就调用子类的，子类没有的就调用基类的。

 当C++编译器在编译的时候，发现被调用的成员函数在基类中定义的是虚函数，这个时候C++就会采用迟绑定技术（late binding)，在运行的时候，依据对象的类型来确定调用的哪个函数，子类有调用子类的，子类没有的就调用基类的。

 如果基类中的成员函数不是虚函数，则这时候的绑定是早期绑定，在编译的时候就已经确定该调用哪个函数。

15，纯虚函数：在类中定义时 eg: virtual void f1()=0;

 纯虚函数没有函数体，含有纯虚函数的类叫做抽象类，抽象类不能实例化对象。当子类从抽象类的基类中派生出来时候，如果没有实现基类中的纯虚函数，则子类也是个抽象类，也不能实例化对象。

 纯虚函数被标名为不具体实现的虚成员函数，纯虚函数可以让类只具有操作的名称而不具有具体的操作的内容，让派生类在继承的时候再给出具体的定义。如果派生类没有给出基类的纯虚函数的具体定义的时候，派生类也为一个抽象类，也不能实例化对象。

16，引用：变量的别名。引用需要在定义的时候用一变量或对象初始化自己。引用一旦在定义的时候初始化，就维系在一个特定的变量或对象上。

 引用不占用物理内存（与定义引用的目标共用同一内存）。指针变量需要占用物理内存，用来存储地址。

 

源文档 <http://blog.youkuaiyun.com/hbyufan/archive/2005/10/11/499228.aspx>