1、c/c++申请动态内存
在c++中，申请动态内存是使用new和delete，这两个关键字实际上是运算符，并不是函数。
而在c中，申请动态内存则是使用malloc和free，这两个函数是c的标准库函数，使用它们必须包含stdlib.h，才能编译通过。
new/delete和malloc/free的相同之处在于，new和malloc都是手动申请动态内存，释放时new则需要delete释放内存，而malloc则需要free释放内存。
它们的不同之处在于，new和delete会自动调用对象的构造和析构函数，而malloc/free则只申请内存。
另外需要注意的是：new的不是数组的话，则直接delete就好，并且只会调用一次析构函数，而new[]的话，则需使用delete[]来释放，并且数组中每一个元素都会调用一次析构函数，调用完析构函数再释放内存。
demo如下:
#include //malloc用到
#include //memset用到
#include //printf用到
int main()
{
//malloc/free使用
int *pmalloc = (int*)malloc(sizeof(int)*4);
//注意malloc分配的内存一定要进行初始化，否则会出现一些奇怪的问题的哦
memset((void*)pmalloc, 0, sizeof(int)*4);
for(int i = 0; i < 4; i++)
{
pmalloc[i] = i;
printf("pmalloc[%d]=%d\n", i, pmalloc[i]);
}
free(pmalloc);
//new/delete使用
int *pNew = new int;
*pNew = 3;
printf("pnew = %d\n", *pNew);
delete pNew;
//new[]/delete[]使用
int *pNewEx = new int[4];
for(int i = 0; i < 4; i++)
{
pNewEx[i] = i;
printf("pNewEx[%d] = %d\n", i, pNewEx[i]);
}
//此处的[]千万不能掉，否则会导致内存泄露的
delete[] pNewEx;
return 0;
}
2、c++继承是什么以及它的优缺点
什么是继承?
顾名思义，继承是一种物体对另外一种物体某些属性，动作的接续。举个例子，比如人这个个体，它的属性包括身高，体重等这些，它的动作则包括吃饭，喝水等等，那么如果另外要定义两种物体，男人和女人，那么这些属性和动作就都可以从人这个物体中继承下来，这，就是继承。当然，继承不只是这么简单，我们后续会陆续说到的。
demo如下：
#include
class CPerson
{
public:
CPerson()
{
height = 170;
weight = 120;
}
~CPerson(){}
void DrinkWater()
{
printf("喝水\n");
}
void HavingDinner()
{
printf("吃饭\n");
}
int GetHeight()
{
return height;
}
int GetWeight()
{
return weight;
}
private:
int height;
int weight;
};
class CMan : public CPerson
{
public:
CMan(){}
~CMan(){}
};
class CWoman: public CPerson
{
public:
CWoman(){}
~CWoman(){}
};
int main()
{
CMan cMan;
cMan.DrinkWater();
cMan.HavingDinner();
printf("男人身高:%d\n", cMan.GetHeight());
printf("男人体重:%d\n", cMan.GetWeight());
CWoman cWoman;
cWoman.DrinkWater();
cWoman.HavingDinner();
printf("女人身高:%d\n", cWoman.GetHeight());
printf("女人体重:%d\n", cWoman.GetWeight());
return 0;
}
- 优点：类继承是在编译时刻静态定义的，且类继承可以较方便地改变父类的实现，实现函数的重用。
- 缺点：首先，因为继承在编译时刻就定义了，所以无法在运行时改变从父类继承的实现，其次，父类一般至少定义了子类的部分行为，父类的任何改变都可能影响子类的行为，也就是说，如果继承下来的实现不适合子类的问题，那么父类必须重写或者被其他的类替换，这种依赖关系限制了灵活性。
从以上对比看，同一种属性既可以是优点，从另外的方面来讲，又是缺点，就看个人在编程过程中的灵活运用了。
3、c++的三大特性
封装、继承、多态。
- 封装是一种技术，它使类的定义和实现分离；
- 继承，从广义上讲，继承有三种实现方式，其一，为实现继承，指使用基类的属性和方法而无需额外编码，其二，可视继承，即子窗体使用父窗体的外观和实现代码，其三，则为接口继承，即仅仅继承属性和方法，实现则滞后到子类去实现，也就是父类使用的是纯虚函数，或者重写父类接口方法，则是虚函数，例如多态的实现就使用了接口继承。
- 多态，简单来讲，就是父类定义了虚函数，子类重新实现该函数，那么当父类指针指向子类时，会调用子类的该方法，这，就是多态。
下面是多态的demo:
#include
#include
class CPerson
{
public:
CPerson()
{
height = 170;
weight = 120;
memset(sex, 0, sizeof(sex));
}
~CPerson(){}
virtual void SetSex() = 0;
void PrintSex()
{
printf("我的性别是:%s\n", sex);
}
private:
int height;
int weight;
//此处sex不能是私有，否则子类中无法使用，因为子类对父类的私有成员有继承权，但没有使用权，也就是只能看，不能摸
protected:
char sex[8];
};
class CMan : public CPerson
{
public:
CMan(){}
~CMan(){}
void SetSex()
{
strncpy(sex, "男人", sizeof(sex)-1);
}
};
class CWoman: public CPerson
{
public:
CWoman(){}
~CWoman(){}
void SetSex()
{
strncpy(sex, "女人", sizeof(sex)-1);
}
};
int main()
{
CPerson* pPerson = new CMan;
pPerson->SetSex();
pPerson->PrintSex();
delete pPerson;
CPerson* pPerson0 = new CWoman;
pPerson0->SetSex();
pPerson0->PrintSex();
delete pPerson0;
return 0;
}
4、子类和父类调用构造函数和析构函数的先后顺序
- 子类对象定义时，先调用父类的构造函数，再调用子类的构造函数；
- 子类对象销毁时，如果父类析构函数是虚函数，那么先调用子类的析构函数，再调用父类的析构函数，否则只会调用父类的析构函数；
demo如下：
#include
class CPerson
{
public:
CPerson()
{
printf("建立父类\n");
}
//注意，父类析构函数一定要是虚函数，这样销毁子类时才会先调用子类的析构函数
virtual ~CPerson()
{
printf("销毁父类\n");
}
};
class CMan : public CPerson
{
public:
CMan()
{
printf("建立子类\n");
}
~CMan()
{
printf("销毁子类\n");
}
};
int main()
{
CPerson* pPerson = new CMan;
delete pPerson;
return 0;
}
执行结果如下：
建立父类
建立子类
销毁子类
销毁父类
5、什么是引用
引用，其实就是给变量取了一个别名，声明引用时要切记初始化，且引用本身不占存储单元，纯粹就是变量多了一个名称而已。
demo如下：
#include
void setValue(int & p_iValue)
{
p_iValue = 10;
}
void setValue1(int p_iValue)
{
p_iValue = 9;
}
int main()
{
int iValue = 8;
int iValue1 = 8;
setValue(iValue);
printf("value=%d\n", iValue); //结果为10
setValue1(iValue1);
printf("value1=%d\n", iValue1); //结果还是8
return 0;
}
6、将引用作为函数参数有哪些特点
- 一是，使用引用传递参数是直接对实参本身进行操作，当需要在函数内部修改传递进来的变量并传出去时，可使用引用；
- 二来，引用是无需重新分配存储空间的，但指针却需要，所以有时使用引用会更有效率；
7、什么时候需要使用常引用
当既要使用引用提高程序的效率，又不能在函数内部修改实参的值时，可使用常引用。
8、将引用作为函数返回值类型的好处和需遵循的规则
好处：在内存中不产生被返回值的副本
需遵循的规则：
(1)不能返回局部变量的引用；
(2)不能返回函数内部动态分配的变量的引用，因为引用只是作为一个临时变量的出现，并未赋予一个实际的变量，该引用所指向的空间无法被释放；
(3)可以返回类成员的引用，但最好是const类型；
(4)为了保证连续使用流操作符(<< >>)重载返回值时，操作的是同一个对象，流操作符重载返回值应该声明为引用
(5)+-*/这四则运算符不能返回引用
9、引用和多态的关系
引用是c++中另外一种实现多态的手段，与指针一样，也是基类的引用可指向派生类的实例。
引用实现多态的demo如下：
#include
#include
class CPerson
{
public:
CPerson()
{
height = 170;
weight = 120;
memset(sex, 0, sizeof(sex));
}
~CPerson(){}
virtual void SetSex()
{
strncpy(sex, "人", sizeof(sex)-1);
}
void PrintSex()
{
printf("我的性别是:%s\n", sex);
}
private:
int height;
int weight;
//此处sex不能是私有，否则子类中无法使用，因为子类对父类的私有成员有继承权，但没有使用权，也就是只能看，不能摸
protected:
char sex[8];
};
class CMan : public CPerson
{
public:
CMan(){}
~CMan(){}
void SetSex()
{
strncpy(sex, "男人", sizeof(sex)-1);
}
};
int main()
{
CMan cman;
CPerson *pPerson = &cman;
pPerson->SetSex(); //此处调用的是子类的SetSex
pPerson->PrintSex();
return 0;
}
10、引用和指针的区别
- 指针通过某个指针变量指向某个对象后，对指针所指向的对象间接操作；
- 引用本身就是变量的别名，所以对引用操作就是直接对所指向的变量进行操作；
- 引用不会重新分配存储空间，但指针却需要重新分配存储空间；