1.3 编程范式

Q1：什么是编程范式？

a) 指的是计算机编程的基本风格或典范模式。

b) 如果说每个编程者都在创造虚拟世界，那么编程范式就是他们置身其中自觉或不自觉采用的世界观和方法论

c) 编程是为了解决问题，而解决问题有多重视角和思路，其中普适而行之有效的模式被归结为范式


                                                                ----by 百度知道

Q2：C++ 的三种编程范式

①.程序模型 —在程序中仅含有普通的函数调用等功能，面向过程的思想

个人理解：C 中常用的仅通过普通操作而编写的程序。 不含类，对象等概念的程序。
Eg:

int main()
            {
                char boy[] = "Danny";
                char * p_son;
                p_son = new char[strlen(boy) + 1];
                strcpy(p_son, boy);
                .....
            }

该程序在整个过程中并未使用任何类等概念

②.抽象数据类型模型（Abstract Data Type Model,ADT/ object-based OB）—在程序中含有类与封装非多态性的思想，将具有某些特性的类型封装在一起，并提供一些运算操作

个人理解：此时设计的程序中含有类对象，此处的抽象与一组表达式 ( public 接口) 一起提供给程序。抽象是将一些有共性的操作提出得到一个新的类型，该类型封装了上述操作，使其运算定义在使用时隐而未知

• 在过程中不包含继承与多态操作

• 备注：在ADT中，程序员处理的是一个拥有固定而单一的类型的实例，在编译时期就已经完全定义好了

  Eg:

            int main()
            {
                string girl = "Anna";
                string daughter;

                //string::operator=()
                daughter = girl;

                //string::operator==()
                if (girl == daughter)

                ....
            }

③.面向对象模型( object - oriented model , OO) — C++ 通过类的指针与引用来支持多态，这种程序设计风格即为面向对象

个人理解：在此模型中有一些彼此相关的类型，通过一个抽象的 base class（用以提供共同的接口）被封装起来。 即含有 继承与多态的思想

• 在此过程中，通过引用，指针与虚函数来实现多态

• 备注：在OO中，指定的对象的真实类型在每一个特定的执行点之前，是无法解析的，是不确定的

  Eg:

class baseClass
            {
            public:
                virtual void func();
            };

            class deriveClass : public baseClass
            {
            public:
                void func();
            };

            int main()
            {
                deriveClass dc;
                baseClass * ptr_bc = &dc;

                //call deriveClass::func()
                ptr_bc->func();
            }

Q3：面向过程与抽象数据类型的个人认识，待改进

以一个简单的示例说明，假设家里养了一只狗，要观测狗当前是否需要进食或睡觉，狗的状态参数可获得，则通过以下两种方式实现该功能

1) 面向过程：

bool dog_eat(int x)
                {
                    return  ( x > 0);
                }

                bool dog_sleep(int x)
                {
                    return  ( x > 0);
                }

                int main()
                {
                    int dog_stat[2];
                    cin >> dog_stat[0];
                    cin >> dog_stat[1];

                    cout << dog_eat(dog_stat[0]) << endl;
                    cout << dog_sleep(dog_stat[1]) << endl;
                }

该对Main函数而言，程序是通过函数的调用实现，各个函数的调用贯穿了整个程序

2) ADT：

class dog
    {
    public:

        dog(int x = 0, int y = 0) : hungry(x), sleepy(y){}
        bool is_hungry() { return (hungry > 0);}
        bool is_sleep() { return (sleepy > 0); }

    private:
        int hungry;
        int sleepy;
    };

    int main()
    {
        int i, j;
        cin >> i >> j;
        dog odog(i,j);

        cout << odog.is_hungry() << endl;
        cout << odog.is_sleep() << endl;
    }

在 main 函数中，程序是通过定义一个dog 对象 odog，通过该对象调用其封装好的函数来判断狗的状态

Q4：表现一个 class object 需要多少内存？

a) 其 nonstatic data member 的总和大小

b) 任何由于对齐需要引入的填充大小

c) 为支持 virtual 而由内部产生的任何额外负担

Q5:关于指针类型

a) 指针类型教导编译器如何解释某个特定的地址中的内存内容及大小。

b) 转换是一种编译器指令，大部分情况下，转换并不改变一个指针所含的真正地址中的值，它只影响编译器解释指针所指地址的内存的内容及大小

c) 可以理解 void* 仅能够有一个地址，而不能够通过其操作对象，是因为编译器根本不知道该如何解释所指地址中的内容

Q6：C++ 通过以下方法来支持多态

a) 一组隐式的转化操作。如：将派生类指针转化为指向其基类的指针

b) 由 virtual function 支持

c) 由 dynamic_cast 运行时转换

Eg:

baseClass 与 deriveClass , 两个类均具有虚函数 void func(),且deriveClass有数据成员 num

        deriveClass d;
        baseClass * ptr_b = &d;
        deriveClass *　ptr_d = &d;


        ptr_b->num;             //不合法
        static_cast< deriveClass*>(ptr_b)->num;     //合法

        deriveClass * d = dynamic_cast< deriveClass *>(ptr_b);   //比前一种类型转换合适，但成本较高

Q7: ADT程序风格与OO程序风格

• ADT被称为OB(object-base),提供一种封装的非多态形式，提供 public接口 与 private实现品，包括数据与算法，但不支持类型的扩充

• 一个OB的设计比一个对等的OO设计速度更快，而且空间更紧凑。

*  快的原因：所有函数调用操作都在编译时期解析完成，对象构建起来不需要设置virtual机制。

* 紧凑的原因：每一个类对象不需要负担传统上为了支持virtual机制而需要的额外的负荷。