爱橙子的OK绷的专栏

第一题： 代码如下：#include <iostream>#include<stdio.h>using namespace std;class UniversityObject{ public: virtual char * getSummary() = 0;};class Student:public UniversityObject{ public

接口隔离原则定义如下：接口隔离原则(Interface Segregation Principle, ISP)：使用多个专门的接口，而不使用单一的总接口，即客户端不应该依赖那些它不需要的接口。根据接口隔离原则，当一个接口太大时，我们需要将它分割成一些更细小的接口，使用该接口的客户端仅需知道与之相关的方法即可。每一个接口应该承担一种相对独立的角色，不干不该干的事，该干的事都要干。这里的“接口”往往

合成复用原则又称为组合/聚合复用原则(Composition/Aggregate Reuse Principle, CARP)，其定义如下：合成复用原则(Composite Reuse Principle, CRP)：尽量使用对象组合，而不是继承来达到复用的目的。合成复用原则就是在一个新的对象里通过关联关系（包括组合关系和聚合关系）来使用一些已有的对象，使之成为新对象的一部分；新对象通过委派调用已

迪米特法则又称为最少知识原则(LeastKnowledge Principle, LKP)，其定义如下：迪米特法则(Law of Demeter, LoD)：一个软件实体应当尽可能少地与其他实体发生相互作用。如果一个系统符合迪米特法则，那么当其中某一个模块发生修改时，就会尽量少地影响其他模块，扩展会相对容易，这是对软件实体之间通信的限制，迪米特法则要求限制软件实体之间通信的宽度和深度。迪米特法则

单一职责原则是最简单的面向对象设计原则，它用于控制类的粒度大小。单一职责原则定义如下：单一职责原则(Single Responsibility Principle, SRP)：一个类只负责一个功能领域中的相应职责，或者可以定义为：就一个类而言，应该只有一个引起它变化的原因。单一职责原则告诉我们：一个类不能太“累”！在软件系统中，一个类（大到模块，小到方法）承担的职责越多，它被复用的可能性就越小，而

开闭原则是面向对象的可复用设计的第一块基石，它是最重要的面向对象设计原则。开闭原则由Bertrand Meyer于1988年提出，其定义如下：开闭原则(Open-Closed Principle, OCP)：一个软件实体应当对扩展开放，对修改关闭。即软件实体应尽量在不修改原有代码的情况下进行扩展。在开闭原则的定义中，软件实体可以指一个软件模块、一个由多个类组成的局部结构或一个独立的类。 为了满

里氏代换原则(Liskov Substitution Principle, LSP)：所有引用基类（父类）的地方必须能透明地使用其子类的对象。里氏代换原则告诉我们，在软件中将一个基类对象替换成它的子类对象，程序将不会产生任何错误和异常，反过来则不成立，如果一个软件实体使用的是一个子类对象的话，那么它不一定能够使用基类对象。例如：我喜欢动物，那我一定喜欢狗，因为狗是动物的子类；但是我喜欢狗，不能据此

如果说开闭原则是面向对象设计的目标的话，那么依赖倒转原则就是面向对象设计的主要实现机制之一，它是系统抽象化的具体实现。 依赖倒转原则定义如下：依赖倒转原则(Dependency Inversion Principle, DIP)：抽象不应该依赖于细节，细节应当依赖于抽象。换言之，要针对接口编程，而不是针对实现编程。依赖倒转原则要求我们在程序代码中传递参数时或在关联关系中，尽量引用层次高的抽象

this指针只能在一个类的成员函数中调用，它表示当前对象的地址。下面是一个例子： void Date::setMonth( int mn ) { month = mn; // 这三句是等价的 this->month = mn; (*this).month = mn; } 1、this只能在成员函数中使用。全局函数，静态函数都不能使用this。！！！！！ 实际

C++中的虚函数的作用主要是实现了多态的机制。关于多态，简而言之就是用父类型别的指针指向其子类的实例，然后通过父类的指针调用实际子类的成员函数。这种技术可以让父类的指针有“多种形态”，这是一种泛型技术。虚函数的作用是实现动态联编，也就是在程序的运行阶段动态地选择合适的成员函数。当程序发现虚函数名前的关键字virtual后，会自动将其作为动态联编处理，即在程序运行时动态地选择合适的成员。C++的虚函数

1、作用：在实现多态时，当用基类的指针操作派生类，在析构时防止只析构基类而不析构派生类的状况发生。！！！！2、实例：#include <iostream>using namespace std;class father{public: father() { mPtr = new int; } ~father()//(1)非虚函数 {

C++ explicit关键字的作用主要是用来修饰类的构造函数，表明该构造函数是显式的，禁止单参数构造函数的隐式转换。！！！！！按照默认规定，只有一个参数的构造函数也定义了一个隐式转换，将该构造函数对应数据类型的数据转换为该类对象。也就是说，如果C++类的构造函数有一个参数，那么在编译的时候就会有一个缺省的转换操作：将该构造函数对应数据类型的数据转换为该类对象，如下面所示：class MyClass

1、类模板1、类模板定义定义一个栈的类模板，它可以用来容纳不同的数据类型，说明如下:template <class T>class stack {private: list* top;public: stack(); stack(const stack&); ~stack(); void push(T&); T& pop(); //…}

#include <iostream>using namespace std;template <class T>class Test;//声明template <class T>ostream& operator<<(ostream& out,const Test<T> &obj);//声明template <class T>class Test{private: int nu

C++中的继承基于一个事实：父类定义的成员函数会一直被子类继承（包括被子类隐藏的部分）。而父类中提供的函数可以有三种： 1)纯虚函数，2)普通虚函数 ，3)普通成员函数。这三种函数类型代表了三种继承设计模式。一个简单的实例代码如下：class Shape {public: virtual void draw() const = 0; virtual void error(const str

在C++的类中有许多种继承方式，而我们在软件设计和编写代码时用得最多的就是public继承，我们很少接触到private继承。但是我们在设计时真的有思考过什么时候应该用public继承，什么时候不该使用public继承，什么时候应该想想那些经常被我们遗忘的知识，让我们从它们被遗忘的角落里重拾它的光芒。例如private继承。As we all know，public继承是塑模出一种is-a关系。什么

1、static 成员在类外初始化2、const 成员（及引用成员）在类的构造函数初始化列表中初始化3、static const /const static 成员可以在类中初始化（实际上是申明）也可以不初始化，同时需要在类外定义#include <iostream>#include <string>using namespace std;class MyTestClass{public:

一、关于覆盖：(1)成员函数的覆盖：子类对父类的成员函数覆盖，必须函数名称一致，参数一致，返回值一致(当然编译器决定)；！！！！！(2)成员变量的覆盖：子类覆盖的仅仅是继承来的那个成员变量，而并不改变原来父类中的变量；！！！！！(3)构造函数从基类开始构造，各个类的同名变量没有形成覆盖，都是单独的变量。子类调用就近原则，如果父类存在相关接口则优先调用，如果父类不存在则调用祖父类接口；当然，如

请考虑标记为A到J的语句在编译时可能出现的情况。如果能够成功编译，请记为RIGHT,否则标记为ERROR。#include<iostream>#include<stdio.h>class Parent{public: Parent(int var=-1) { m_nPub=var; m_nPtd=var; m_nPrt=var;

面向对象的三个基本特征是：封装、继承、多态。一、封装封装是对象和类概念的主要特性。封装，也就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。二、继承面向对象编程 (OOP) 语言的一个主要功能就是“继承”。继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。通过继承创建的新类称为“子类”或“派

在公有继承中，基类成员的可访问性在派生类中保持不变。基类的私有成员在派生类中还是私有成员，不允许外部函数和派生类的成员函数直接访问，但可以通过基类的公有成员函数访问。基类的公有成员和保护成员在派生类中仍是公有成员和保护成员，派生类的成员函数可直接访问它们，而外部函数只能通过派生类的对象间接访问它们。如以下程序：

在私有继承中，派生类以私有方式继承基类。基类的公有成员和保护成员在派生类中成为私有成员，它们能被派生类的成员函数直接访问，但不能被类外函数访问，也不能在类外通过派生类的对象直接访问。派生类不能直接访问基类的私有成员，而只能派生类的成员函数中通过基类的公有或保护成员函数间接访问。在设计基类时，通常都要为其私有成员提供能够访问它们的公有成员函数，以便派生类和外部函数能间接访问它们。例如，下面的程序以私有

一、保护继承在保护继承中，基类的公有成员在派生类中成为保护成员，基类的保护成员在派生类中仍为保护成员，所以，派生类的所有成员在类的外部都无法访问它们。例如，下面程序实现类Derived对基类Base的保护继承，仔细理解保护继承后派生类对象如何访问基类的成员。 在上述代码中，类Base定义了保护成员变量b，类Derived**保护继承**自类Base。在主函数main（）中，由类Derived创

new一个类对象和使用类名创建一个对象有什么区别？ 用new来给一个类的对象分配空间，和使用类名称来定义一个类的对象，有什么区别？难道区别只是new的返回值是个指针，而对象定义得到的是变量名么？或者是在存储空间上不同？有什么不同呢？具体什么时候使用哪个方法呢？ ——解决方案——————–对，存储空间上不同。 new出来的在堆上 直接定义的在栈上 ——解决方案——————–用法似乎高手都喜欢

一、浅拷贝C++默认的拷贝构造函数是浅拷贝浅拷贝：对象的数据成员之间的简单赋值，如你设计了一个类而没有提供它的拷贝构造函数，当用该类的一个对象去给令一个对象赋值时所执行的过程就是浅拷贝。#include <iostream>using namespace std;class A {public: A(int _data) : data(_data){} A(){} in

用多态实现线性表（队列，串，堆栈），要求具备线性表的基本操作：插入，删除，测长等。#include <iostream>//#include<stdlib.h>using namespace std;template <class T>class tcontainer{ virtual void push(const T&) = 0; //插入 virtual void

多态性可以简单的概括为“1个接口，多种方法”，在程序运行的过程中才决定调用的机制1、用virtual关键字申明的函数叫做虚函数，虚函数肯定是类的成员函数。 2、存在虚函数的类都有一个一维的虚函数表叫做虚表。类的对象有一个指向虚表开始的虚指针。虚表是和类对应的，虚表指针是和对象对应的。 3、多态性是一个接口多种实现，是面向对象的核心。分为类的多态性和函数的多态性。 4、多态用虚函数来实现！！！，

如果你只是声明一个空类，不做任何事情的话，编译器会自动为你生成一个默认构造函数、一个拷贝默认构造函数、一个默认拷贝赋值操作符和一个默认析构函数。这些函数只有在第一次被调用时，才会别编译器创建。所有这些函数都是inline和public的。定义一个空的C++类，例如class Empty{}一个空的class在C++编译器处理过后就不再为空，编译器会自动地为我们声明一些member functio

一、C++中的struct对C中的struct进行了扩充，它已经不再只是一个包含不同数据类型的数据结构了，它已经获取了太多的功能。struct能包含成员函数吗？ 能！struct能继承吗？ 能！！struct能实现多态吗？ 能！！！最本质的一个区别就是默认的访问控制，体现在两个方面：1）默认的继承访问权限。struct是public的，class是private

对于以下程序：#include <iostream>using namespace std;class Base{private: int a; int b;public: Base(int i):b(i),a(b){} Base():b(0),a(b){} int get_a(){return a;}

多态基类的析构函数应该为虚函数#include <iostream>using namespace std;class Base{public: Base() { cout<<"Base()"<<endl; } virtual ~Base()//多态基类的析构函数应该为虚函数！！！！！！ { cout<<"~Base()"

一、基本知识当将类的某个数据成员声明为static时，该静态数据成员只能被定义一次，而且要被同类的所有对象共享。各个对象都拥有类中每一个普通数据成员的副本，但静态数据成员只有一个实例存在，与定义了多少类对象无关。静态方法就是与该类相关的，是类的一种行为，而不是与该类的实例对象相关。静态数据成员的用途之一是统计有多少个对象实际存在。静态数据成员不能在类中初始化，实际上类定义只是在描述对象的蓝图，在其中

1.友元函数的简单介绍1.1为什么要使用友元函数在实现类之间数据共享时，减少系统开销，提高效率。如果类A中的函数要访问类B中的成员（例如：智能指针类的实现），那么类A中该函数要是类B的友元函数。具体来说：为了使其他类的成员函数直接访问该类的私有变量。即：允许外面的类或函数去访问类的私有变量和保护变量，从而使两个类共享同一函数。实际上具体大概有下面两种情况需要使用友元函数：（1）运算符重载的某些场合

联编就是将模块或者函数合并在一起生成可执行代码的处理过程，同时对每个模块或者函数调用分配内存地址，并且对外部访问也分配正确的内存地址，它是计算机程序彼此关联的过程。按照联编所进行的阶段不同，可分为两种不同的联编方法：静态联编和动态联编。静态联编是指在编译阶段就将函数实现和函数调用关联起来，因此静态联编也叫早绑定，在编译阶段就必须了解所有的函数或模块执行所需要检测的信息，它对函数的选择是基于指向对象的

构造函数不能声明为虚函数，析构函数可以声明为虚函数，而且有时是必须声明为虚函数。不建议在构造函数和析构函数里面调用虚函数。构造函数不能声明为虚函数的原因是:解释一：所谓虚函数就是多态情况下只执行一个。而从继承的概念来讲，总是要先构造父类对象，然后才能是子类对象。如果构造函数设为虚函数，那么当你在构造父类的构造函数时就不得不显式的调用构造。还有一个原因就是为了防错，试想如果你在子类中一不小心重写

拷贝构造函数在以下三种时机被调用1、 对象以值传递的方式传入函数参数#include <iostream>using namespace std;class CExample{private: int a;public: //构造函数 CExample(int b) { a = b; cout<<"creat: "<<a<<end