问：
int a[3]; // 一维数组 char b[3][5]; // 二维数组 float c[3][5][7]; // 三维数组
比较a+1,b+1,c+1；c[2][3][4]相对数组起始地址的偏移
答：a+1代表a[1]的地址，是一级指针，要去a+1里面的内存，只需cout<<*(a+1)即可；
b+1代表b[1]的地址，是二级指针，指向从b[1][0]开始的之后的一段内存，若要取出内容，需要用2个星号，因为是二级指针，**(b+1)代表b[1][0]，*(*(b+1)+1)代表b[1][1]；
c+1代表c[1]的地址，是三级指针，指向从c[1][0][0]开始的地址，若要取出内容，需要3个星号，因为是三级指针，***c代表c[0][0][0]。我们用cout<<c,cout<<*c,cout<<**c，这三次的输出结果一样，但含义不同；
这里需要注意的一个问题：由于b是char型的，用cout输出跟b有关的信息会有所不同。cout<<**b：输出b[0][0]这个字节，b[0][0]里面保存的是该字节的ASCII码；cout<<*b：输出的是从b[0][0]开始的字符串，到空字符null（ASCII码为0）为止；cout<<b：输出指针b本身的值，即b[0][0]的地址；
我们测试以下语句：
cout<<sizeof(c)<<endl; cout<<sizeof(*c)<<endl; cout<<sizeof(**c)<<endl; cout<<sizeof(***c)<<endl;得出的结果为：420 140 28 4
c是三级指针，指向整个数组区域，3*5*7=105，105*4=420
*c是二级指针，指向从c[0][0][0]开始到c[0][4][6]结束的一段，5*7=35，35*4=140
**c是一级指针，指向从c[0][0][0]开始到c[0][0][6]结束的一段，7*4=28
***c是指针所指向内容float，sizeof(***c)相当于sizeof(float)
c[2][3][4]地址偏移的计算：2*5*7+3*7+4=95，95*4=380，偏移量为380个字节
问：构造函数与拷贝构造函数相关
答：拷贝构造函数与构造函数一样，若不自定义，会调用默认的函数进行操作，默认的拷贝构造函数可以完成拷贝，默认的构造函数可以完成构造。
一旦自定义了构造函数，就不能调用默认的函数了。比如自定义了带参数的构造函数，这时去使用无参数的构造函数时会报错。构造函数里无语句也可构造对象。
一旦自定义了拷贝构造函数，同样不能调用默认的拷贝构造函数了。与构造函数不同的是，拷贝构造函数里什么都不写，此时完成不了拷贝。拷贝构造函数在以下4种情况调用：1.初始化Cat cat1(cat2); 2.初始化Cat cat1 = cat2;（cat2 = cat1非初始化而是赋值时，不调用拷贝函数，而是调用默认的赋值函数，若Cat类中有new语句，则需要自定义赋值函数，同默认的拷贝函数，默认的赋值函数也是位拷贝） 3.函数参数fun(cat1); 4.函数返回return cat1;
拷贝构造函数也是构造函数，当对象初始化Cat cat1(cat2);此时不调用构造函数，而是调用拷贝构造函数完成构造和初始化的功能。
问：静态成员变量相关
答：在类内的只是静态变量的声明，静态变量的定义必须在类外，声明：static int x; 定义：int CLASSNAME::x = 1; 在类外使用静态变量时，可以用CLASSNAME::x或者对象名.x来调用，对象名1.x和对象名2.x是一样的，因为静态变量属于整个类。
问：全局变量和全局静态变量的区别
答：他们都是在全局数据区，唯一一个重要的区别就是，static全局只对当前文件有效，不支持extern被外部引用，在开发中的全局变量应声明为static，防止其他文件同名变量对此变量的使用。
问：返回引用与返回非引用相关
答：若返回局部变量的引用，将会出问题，i和j在函数结束后生存周期到，返回它们的引用得不到想要的结果。
int &Max(int i, int j)
{
return i>j ? i : j;
}调用函数时，函数会为 输入的实参建立一个副本，该副本属于临时变量，返回时就返回这个副本，然后将该临时变量释放。
#include <iostream>
using namespace std;
class CText
{
public:
~CText()
{
cout<<"析构了"<<this<<endl;
}
};
CText& fRefer(CText &a)
{
return a;
}
CText fNoRefer(CText &a)
{
return a;
}
int main(int arge,char*argv[ ])
{
CText a;
cout<<"a的地址:"<<&a<<endl;
cout<<endl<<"------引用类型返回值------"<<endl;
a=fRefer(a);
cout<<endl<<"------非引用类型的返回值------"<<endl;
a=fNoRefer(a);//此处会析构一个与a地址不一样的内存，说明析构的临时变量
cout<<endl<<"------main结束------"<<endl;
return 0;
}
参看下面的例子：由于重载运算符=函数返回的不是引用，所以将返回值++没有意义，返回的是临时变量，待该临时变量赋值给别的变量后，这个临时变量的使命就完成了，就被释放了。
class CText
{
public:
~CText()
{
cout<<"析构了"<<this<<endl;
}
CText operator++()
{
x++;
return *this;
}
CText operator=(CText &obj)
{
x = obj.x;
return *this;
}
private:
int x;
};
int main(int arge,char*argv[ ])
{
CText a(1),b(2);
(b = a)++;
return 0;
}
问：对象在内存中的布局如何
答：这是一个比较大的问题，有许多种情况，这里给出一种最简单的情况
1.类的数据成员之间的间隔是类中最大数据类型的整数倍
2.数据不能跨越间隔存储
3.成员变量的保存顺序与声明顺序有关
class A
{
char a;
public:
short b;
char c;
};
A中short型最大，占2个字节，所以就2字节为基本单位扩展，这里A占6个字节，我们换一下顺序就可以提高利用率：
class A
{
char c;
char a;
public:
short b;
};这里A占4个字节
当我们考虑继承时，情况又会如何呢？
class A
{
char a;
public:
short b;
char c;
};
class B:public A
{
public:
int d;
};A占6个字节，B占12个字节，不要以为A中的私有变量在B中就不会出现继承时，要按照B的要求进行对齐，B中的int占4个字节，所以要把A占的6个字节补齐为8个字节，内存图如下：
