程序设计基本概念（5） 面向对象

1. C++空类，系统产生的成员函数，包括构造函数、析构函数、拷贝构造函数和赋值函数。

2. C++中struct和class的区别。

class默认是private, struct是public。

3. 关于class中static变量。当同一类的所有对象使用一个量时，对于这个共用的量，可以用静态数据成员变量，这个变量对于同一类的所有的对象都取相同的值。

（1）类体外的函数定义不能指定关键字static；

（2）静态成员之间可以相互访问，包括静态成员函数访问静态数据成员和访问静态成员函数；静态成员函数不能访问非静态成员函数和非静态数据成员；静态成员变量只能被静态成员函数调用。

（3）非静态成员函数可以任意地访问静态成员函数和静态数据成员；

见下面的例子：

#include<iostream>
using namespace std;

class test
{
private:
    int x;
    int y;
public:
    static int num;
    static int Addnum();
    static void PrintNum()
    {
       cout << Addnum()<<endl;
    }
};

int test::Addnum()
{
    return ++num;

}
int test::num = 10;


int main(void)
{
     test a;
     cout<<test::num<<endl;       //10
     test::num = 20;
     cout<<test::num<<endl;       //20
     cout<< a.num <<endl;         //20
     cout<<test::Addnum()<<endl;  //21
     test::PrintNum();            //22
     cout<<a.Addnum()<<endl;      //23
     return 0;
}

1. class初始化列表中的初始化变量顺序为成员变量的声明顺序。例如：

#include<iostream>
using namespace std;

class test
{
public:
    test():m_x(1),m_y(m_x)
    {

    };
    int m_x;
    int m_y;
};

void main()
{
    test t;
    std::cout << t.m_x <<std::endl;
    std::cout << t.m_y <<std::endl;
}

上面的例子中，初始化的顺序为m_x =1, m_y = m_x。

5. 析构函数和虚函数的关系

#include<iostream>
using namespace std;

class A
{
public:
     virtual ~A() {cout<<"~A()\n";}
};

class B: public A
{
public:
     ~B() {cout<<"~B()\n";}
};

void main()
{
    A* p = new B;
    delete p;
}

其中,父类为class A ，子类为class B.我们发现利用当A* p = new B; 当delete p时候，如果A的析构函数为虚函数，则析构子类和父类，如果A不为虚函数的时候，则只析构父类。 因为，如果是使用了虚函数，class会保存一张虚函数表，表是在构造的时候就保存好了。而且子类的函数地址会覆盖父类。当析构时候，调用的是子类的析构函数。可以避免了内存泄露情况的发生。

6. class的explicit的关键字

explicit在构造函数前面，消除了隐含转换。

例如：

#include<iostream>

class people1
{
public:
    int age;
    explicit people1(int a)
    {
        age = a;
    }
};

class people2
{
public:
    int age;
    people2(int a)
    {
        age = a;
    }
};


void main()
{
    people1 p1(10);
    std::cout << p1.age <<std::endl;
    people2 p2 = 10;
    std::cout << p2.age <<std::endl;
}

7. 拷贝构造和赋值函数
类的copy构造函数，主要的格式为CExample(const CExample& C)，其中CExample为类名。

主要在下面三种情况调用copy构造函数：

1. 对象以值传递的方式传入函数参数。

void g_Fun(CExample C)  
{  
}

  int main()  
{ 
   CExample test(1);  
   g_Fun(test);
}

1. 对象以值传递的方式从函数返回。

CExample g_Fun()  
{  
  CExample temp(0);  
  return temp;  
}

1. 对象需要通过另外一个对象进行初始化。下面产生对象B的过程中，都调用了copy构造函数。

CExample A(100);
CExample B = A; 
// CExample B(A);

赋值函数

例如string & string:: operate = (const string & other){}

多态

多态性：一个接口，多种方法。

重载和覆盖

overload: 一个与另一个函数同名，但是参数表不同。

override: 派生类覆盖基类的虚函数。

友元

友元是定义在类外面的普通函数，但是在类体内要进行说明。关键字为friend。友元不是成员函数，但是它可以访问类中priviate成员。

虚函数继承

#include<iostream>

class A
{
    char aa[3];
public:
    virtual void af(){};
};

class B : public virtual A
{
    char bb[4];
public:
    virtual void bf(){};
};

class C: public virtual B
{
    char cc[3];
public:
    virtual void cf(){};
};

void main()
{
    std::cout << sizeof(A) << std::endl;
    std::cout << sizeof(B) << std::endl;
    std::cout << sizeof(C) << std::endl;

}

上面的结果是 8， 20 ，32原文链接: https://www.cnblogs.com/bruce81/archive/2013/03/02/2941102.html

欢迎关注

微信关注下方公众号，第一时间获取干货硬货；公众号内回复【pdf】免费获取数百本计算机经典书籍