C++学习总结 复习篇2

 

延续上一小节内容：下面继续讲解虚函数和多态

1. 虚函数和多态

1. 基类指针可以指向任何派生类的对象，但是不能调用派生类对象的成员。
2. 但是，基类可以调用覆盖了虚函数的函数。（现在调用将来，这有问题，说明现在影响了将来。）
3. 基类可以被继承，如果虚函数没有被实现，可以继续被下一个类继承。
4. 当派生类没有能够覆盖虚函数的时候，若派生类的对象访问这个函数，那么此时将使用基类定义的函数。（现在调用过去，没有问题，已经定义过）

举例：

// BlankTest.cpp : 定义控制台应用程序的入口点。

//知识点：虚函数

//虚函数的强大之处在于能够预测未来。

//记住：基类指针可以指向任何派生类型的对象，但不能访问派生类型对象中定义的成员，但是可以调用虚函数（纯虚也可以）的实现函数。

#include "stdafx.h"

#include <iostream>

using namespace std;

 

class A

{

public:

    virtual void f()

    {

        cout << "我是虚函数 " << endl;

    }

protected:

private:

};

 

class B : public A

{

public:

    void f()

    {

        cout << "我派生自A " << endl;

    }

};

 

class C : public B

{

public:

    void f()

    {

        cout << "我派生自B"<< endl;

    }

};

 

class D :public A// 没有覆盖A中的虚函数，此时D的对象调用f这个函数的时候，将调用基类当中的函数。

{

public:

    void ff()

    {

        cout << "没有覆盖虚函数！" << endl;

    }

};

int _tmain(int argc, _TCHAR* argv[])

{

    A *p = new A();

    B b;

    C c;

    D d;

    p->f();

    p = &b;

    p->f();

    p = &c;

    p ->f();

    p = &d;

    p->f(); //基类指针可以调用虚函数的实现函数。即使它是派生类对象当中的成员。

    //p -> ff(); //基类指针没法调用派生类当中的成员。

    d.ff();

    return 0;

}

纯虚函数与抽象类

解释：含有一个或多个的纯虚函数的类叫抽象类。

特点：抽象类只能被继承不能被实例化。派生类必须覆盖这个纯虚函数，这个和虚函数有点不同，虚函数中，它的派生类不一定要必须覆盖。有时候，我们可以这样理解：

抽象类的派生类，才是我们需要的类，我们通过派生类，就可以利用基类的接口，调用基类的成员，而且可以基于派生类的不同而调用不同版本的虚函数的实现函数。

即：可以根据自己的需要，对纯虚函数重新定义，来满足自己的需要。

举例：

// BlankTest.cpp : 定义控制台应用程序的入口点。

//知识点：虚函数

//虚函数的强大之处在于能够预测未来。

//记住：基类指针可以指向任何派生类型的对象，但不能访问派生类型对象中定义的成员，但是可以调用虚函数（纯虚也可以）的实现函数。

#include "stdafx.h"

#include <iostream>

using namespace std;

 

class A

{

public:

    virtual void f() = 0 //纯虚函数

    {

        cout << "我是虚函数 " << endl;

    }

 

    void aa()

    {

        cout << "基函数的成员函数！" << endl;

    }

protected:

private:

};

 

class B : public A

{

public:

    void f()

    {

        cout << "我派生自A " << endl;

    }

};

 

class C : public B

{

public:

    void f()

    {

        cout << "我派生自B"<< endl;

    }

};

 

class D :public A// 没有覆盖A中的虚函数

{

public:

    void ff()

    {

        cout << "没有覆盖虚函数！" << endl;

    }

};

int _tmain(int argc, _TCHAR* argv[])

{

    B b;

    C c;

    //D d; //D没有实现纯虚函数，所以不能定义对象。

    b.f();

    b.aa();

    c.f();

    c.aa();

    return 0;

}

 

多态：

多态分为两种： 编译时的多态与运行时的多态。

而编译时的多态一般指早期绑定；运行时的多态指动态绑定。

早期绑定：函数的重载，函数的调用以及运算符重载。简单点说，就是在编译的时候就可以确定调用某一个函数了，这个函数是确定的。

动态绑定：一般指虚函数。即：运行时才能确定函数的调用。

 

1. C++预处理器

   预处理器先用编译器对源代码进行处理。

   主要有以下几种： #include #define #ifndef #if #else

   我们可以应用预处理器提高编程的效率。

   举例：

   // BlankTest.cpp : 定义控制台应用程序的入口点。

   #include "stdafx.h"

   #include <iostream>

   using namespace std;

    

   //#define DEBUG //通过这行可以决定 调试信息 的有无，这个比较好。赞一个。

   int _tmain(int argc, _TCHAR* argv[])

   {

   #ifdef DEBUG

       cout << "我在调试模式下！" << endl;

   #endif // _DEBUG

    

       cout << "我在运行模式下"<<endl;

       return 0;

   }

2. C++运算符重载

   运算符重载和函数重载有异曲同工之妙，不同之处在于运算符重载，载的是构造类型的数据，基本数据类型的数据不需要重载。重载的目的是为了让运算更加简洁、明白。

   所谓的重载是对里面的运算符进行重新使用，而且只是针对这一种运算符，不是其他的。

   语法格式：

   返回类型 operator 单目运算符（参数列表）

   {

   //函数体

   }

   返回类型 operator 双目运算符（虚参1， 虚参2）

   {

   //函数体

   }

   注：对于双目运算符，两个虚参中至少得有一个是构造类型。

3. C++命名空间

   所谓命名空间，你心里面想着文件夹的概念就OK了，主要用处就是为了避免冲突。

   比如，我在a文件夹下建立文件b，我也可以在c文件夹下建立文件b，但就是不能在 a 文件夹下，建立两个b。

   格式：

   namespace 命名空间名称

   {

   //函数体

   }

   而且，命名空间也要符合命名规范，所以对于命名空间名称我们也是可以起别名的，比如 namespace geography information system,我们可以简写为： namespace GIS = geography information system;

   以上只是一种使用别名的规范而已。

   Using 的作用：就是使当前文件夹下所有的函数名 暴露 在源程序中，这样我们就可以省略写 "命名空间名：: 使用到的名称或命令"。

   举例：

   // BlankTest.cpp : 定义控制台应用程序的入口点。

   #include "stdafx.h"

   #include <iostream>

   //using namespace std;

   using std::cout;

    

   //以下两个同名的函数：之所以不报错，是因为他们在不同的命名空间下。

   //#define DEBUG //通过这行可以决定 调试信息 的有无，这个比较好。赞一个。

   namespace zhu

   {

       void show()

       {

           cout << "我在zhu这个namespace下！" << std::endl;

       }

   }

   namespace xue

   {

       void show()

       {

           cout << "我在xue这个namespace下！" << std::endl;

       }

   }

   int _tmain(int argc, _TCHAR* argv[])

   {

   zhu::show();

        xue::show();

   #ifdef DEBUG

       cout << "我在调试模式下！" << endl;

   #endif // _DEBUG

    

       cout << "我在运行模式下"<< std::endl;

       return 0;

   }

命名空间和类联系在一起，珠联璧合，天下无敌。命名空间是类的一种有效的组织结构方式，我们用命名空间可以有效的将类进行分类管理，每个类有一个命名空间，这样我们在做大型程序开发时，可以为类库添加结构和层次的组织关系。

举例：

// BlankTest.cpp : 定义控制台应用程序的入口点。

#include "stdafx.h"

#include <iostream>

//using namespace std;

using std::cout;

 

//以下两个同名的函数：之所以不报错，是因为他们在不同的命名空间下。

//#define DEBUG //通过这行可以决定 调试信息 的有无，这个比较好。赞一个。

namespace zhu

{

    void show()

    {

        cout << "我在zhu这个namespace下！" << std::endl;

    }

}

namespace xue

{

    void show()

    {

        cout << "我在xue这个namespace下！" << std::endl;

    }

}

 

namespace kui

{

    class A

    {

    public:

        void show()

        {

            cout << "我是属于kui命名空间里面A类里面的函数！" << std::endl;

        }

    };

}

namespace kui1

{

    class A

    {

    public:

        void show()

        {

            cout << "我是属于kui1命名空间里面A类里面的函数！" << std::endl;

        }

    };

}

int _tmain(int argc, _TCHAR* argv[])

{

zhu::show();

     xue::show();

 

     kui::A a;

     a.show();

 

     kui1::A b;

     b.show();

#ifdef DEBUG

    cout << "我在调试模式下！" << endl;

#endif // _DEBUG

 

    cout << "我在运行模式下"<< std::endl;

    return 0;

}