程序设计基本概念（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;
}

4. 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);
}

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

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

3. 对象需要通过另外一个对象进行初始化。下面产生对象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