Arivn_emb

#include using namespace std;class rectangle{  public:class point{public:void setx(int X){x=X;}void sety(int Y){y=Y;}int getx()const{return x;}int gety()const{return y;}private

#includeusing namespace std;class father{  public:  virtual void smart(){cout //父类的smart()函数};class son:public father{  public:  virtual void beautiful(){cout //子类的beautiful函数

每个对象创建虚函数时，对象都得记录这个虚函数 ，因此编译器简历 了一个叫做T表的虚函数表，每个对象都有一个指向该表的指针，叫做虚表指针，该指针用来指向虚函数表。相反虚函数表也有一个指针指向该对象，当创建派生类对象的基类部分时，该对象的指针就自动初始化为指向虚函数表的正确部分。当调用派生类对象的构造函数时，这个对象就会添加到虚函数表中去，并且将指针指向该对象的重载函数。当使用指向基类的指

#include  using namespace std;class father{   public:   virtual void run()const{cout};class son:public father{   public:   void run()const{cout};class daughter:public father{

#include "iostream"using namespace std;class father{public:  void smart(){cout  //父类的smart()函数  virtual void beautiful(){}       //该虚函数只是给son类做个接口，没有什么实际功能  virtual ~father(){cout

#include "iostream"using namespace std;class A{  public:  A(){cout  virtual void func(){cout  virtual ~A(){cout};class B:public A{  public:  B(){cout  void func(){cout  ~B(

#include "iostream"using namespace std;class A{  public:   virtual int get(){return 0;}};class B:public A{  public:   int get(){return 1;}};void main(){  B b;  A*p=&b; 

#includeusing namespace std;class A{   public:   virtual int get(){return 1;}};class B:public A{   public:   int get(){return 2;}};void main(){   while (1)   {      cou

//在运行时的静态联编的例程如下：#includeusing namespace std;class A{   public:   int get(){return 1;}};class B:public A{   public:   int get(){return 2;}};void main(){   while (1)   {

#includeusing namespace std;class A{   public:   int get(){return 1;}};class B:public A{   public:   int get(){return 2;}};void main(){   A a;   int one=a.get();   cout

联编是指一个计算机程序自身彼此关联（使一个源程序经过编译、连接，成为一个可执行程序）的过程，在这个联编过程中，需要确定程序中的操作调用(函数调用)与执行该操作(函数)的代码段之间的映射关系，按照联编所进行的阶段不同，可分为静态联编和动态联编。静态联编：调用函数和被调函数在程序编译时，他们在内存中的地址和映射关系已经确定好，动态联编：内存和地址映射关系不确定，加virtual 为动态联编，自

#include using std::cout;using std::cin;using std::endl;class father{  public:  father(){cout  virtual ~father(){cout  virtual void smart()const{cout};class mother{  public:

抽象类为最高基类#include using namespace std;class shape{  public:  shape(){}  virtual ~shape(){}  virtual float length(){return 0;}  virtual float area(){return 0;}  virtual void show(){}

由于任何一个从抽象类派生的新类都会继承纯虚函数的特征--无任何功能因此要创建这个新类的对象必须为每一个纯虚函数赋予功能#include using namespace std;class shape{  public:  virtual double area()=0;};class A:public shape{  protected:  doub

=======================什么是友元类=======================      当一个类B成为了另外一个类A的“朋友”时，那么类A的私有和保护的数据成员就可以被类B访问。我们就把类B叫做类A的友元。=======================友元类能做什么=======================      友元类可以通过自

#include using namespace std;class human //抽象类human{   public:   virtual void run()=0; //纯虚函数run   virtual void eat()=0; //纯虚函数eat};class mother:public human //派生类mother从抽象类human继承{

#include using namespace std;void square(int &x,int &y){   x=x*x;   y=y*y;}void cube(int &x,int &y){   x=x*x*x;   y=y*y*y;}void Swap(int &x,int &y){   int z;   z=x;   x

数组名就是指向数组第一个元素的常量指针函数名也是指向函数第一条指令的常量指针正常情况下，程序在编译后，每个函数都有一个首地址，也就是函数第一条指令的地址我们用一个指针来保存这个地址，这个指针就是函数指针，该指针可看做是函数名，因此我们可以通过该指针调用函数

#include using namespace std;class A {public:void func(){cout//定义公有成员函数func()，用该函数访问私有静态成员变量xprivate:static int x; //将静态成员变量x声明为私有};int A::x=1000;                 //定义并初始化静态成员变量int

1.静态成员变量是属于整个类的全局变量，它不单属于某个对象，普通成员变量是属于类中对象的变量。它不能被所有对象共享2.静态成员变量必须在全局进行定义，而成员变量由于是属于该类某个对象的，而不是属于整个类的，因此不用在全局进行定义。3.在使用静态成员变量时，可以不限定为某个具体的对象，只与类名连用即可如 A：：total 而不用 A a; a.total;4.静态成员在没有对

#include using namespace std;class aspl         //将阿司匹林声明为一个aspl类，那么每箱阿司匹林就是该类的一个对象      {   public:   aspl(float p){price=p;TotalPrice=p+TotalPrice;}    //在构造函数中实例化该对象的私有成员变量price，这样就得到了一箱阿

/*#include using namespace std;class A{   public:   void static show(){cout//定义静态成员函数show，输出私有静态成员变量n并将n自加   private:   static int n;   //声明私有静态成员变量n};int A::n=0; //定义私有静态成员变量nin

在单一继承可以实现的情况下，不要使用多继承

#include using namespace std;class animal{  public:  animal(int);  virtual ~animal(){cout  virtual int getage() {return itsage;}  virtual void sleep()=0; //声明6个纯虚函数  virtual void eat

#include  using namespace std; class poser{  public:  virtual void beat()const{cout  protected:  int age;};class Ali:public poser{  public:  void beat()const{cout};class Le

#include  using namespace std; class father{  public:  father():age(54){cout  ~father(){cout  void jump()const {cout  virtual void run()const{cout  protected:  int age;};class

在堆中创建的对象都是匿名的，因此创建的时候必须用类名来创建，而且要访问它们必须用指针，对的概念在数组里还有详细的讲解father*pfather = new son;解释：该段语句是在堆上创建一个新的son对象，并且返回指向该对象的指针，而赋值操作符=又将该指针赋值给指向father的指针。这样的好处是son对象可以直接访问father的数据和函数

#include using namespace std;class A {public:    A(int x){i=x;cout    ~A(){coutvoid get(){coutprivate:    int i;};int main(){    A a(99); //调用A(int x)输出"构造函数执行!99"    a

#include using namespace std;class A {public:A(){}A(int i){x=i;}private:int x;};int main(){  A a;  A b(3);  return 0;}

现在的我无比的渴望创业，做好了一切准备6月份从广州回到河南，带着对未来美好的憧憬，做好干一番事业的准备，下定决心。世事难料，一个多年的好朋友出卖了我 ，在公司发展最迅速的时候，抛弃了我，经历这一切，我深深的体会到交友的重要性我还是涉世不深。在河南还是有不少人脉关系，凭借这点，我又得到一次创业的机会，经一个朋友介绍目前也是在等待这个朋友的一个朋友回到河南，商讨关于这件事初步估

//创建num类：#include using namespace std;class num {public:    num(){n=1;}    ~num(){}    int get()const{return n;}    void set(int x){n=x;}private:    int n;};int main(){ 

//delete运算符自动调用析构函数的例程如下：#include using namespace std;class A {public:    A(){cout    ~A(){cout};int main(){    A *p=new A; //自动调用构造函数    delete p; //自动调用析构函数    return 0;}

不带参数的成员变量的初始化，在构造函数中引入成员属性并初始化一个值#include using namespace std;class rectangle{public:  rectangle():length(3),width(5){cout          int area(){return length*width;}  private:  in

#include using namespace std;class A{public:A(int i,int j){n=i;m=j;} //构造函数带两个参数，并将参数的值分别赋给两个私有成员A(A&t){cout //模拟的默认复制构造函数，通过别名t访问对象，然后将该对                        //象的成员赋给新对象的成员，完成复制工作v

//成员变量的初始化顺序的例程如下：#include using namespace std;class demo {public:    demo(){x=0;cout    demo(int i){x=i;cout    ~demo(){cout    int get(){return x;}    void set(int i){x=i;}priv

多个构造函数重载#include using namespace std;class rectangle{public:rectangle(){coutrectangle(int l,int w){length=l;width=w;cout       length * width rectangle(int l,int w,int h){length=l;wi

/*使用NEW运算符在堆中开辟一块新空间，例程如下：#include using std::cout;class A{public:A(){cout};int main(){A *p;     //声明一个属于A类的指针pp=new A; //使用new运算符创建一块堆中空间，它的大小由类A的数据成员的类型和数量//来定，由于堆在内存中都是匿名的，因

#include using namespace std;class A {public:    A(){x=new int;*x=5;}     //创建一个对象的同时将成员指针指向的变量保存到 新空间中    ~A(){delete x;x = NULL;} //析构对象的同时删除成员指针指向的内存空间，为了稳妥起见将指针赋为空    A(const A &a)

派生是继承后，又修改某些属性或者增加某些功能#includeclass father{  private:  int Ft,Fh;  public:  void SFtall(int Ftall){Ft=Ftall;} //设置父亲身高  void SFweight(int Fweight){ Fh=Fweight; } //设置体重  void coutF()

1.公有派生的前提下，基类的公有成员在派生类中仍然是公有的2.公有派生的前提下，派生类将基类的保护成员也原封不动地继承过来了3.公有派生的前提下，基类的私有成员在派生类中不可访问，只能通过父类的public函数借口来访问私有成员