1.在函数内部里面定义某局部变量为static，则在程序运行的过程中，调用其，并初始化，而后再次进行初始化时则无效。依旧保持先前的数值
2.关于拷贝构造函数调用的次数。直接见题目
A function(A a){
return a;
}
void main(){
A a;
A b=function(a);
}
我们来分析下 构造函数，拷贝构造函数调用的情况。
所谓拷贝构造函数(归根到底还是个构造函数)就是利用一个已知对象去初始化另外一个同类的对象，其表现形式 A(const & A){}
A a，调用A的默认构造函数，构造出一个A的对象。
function(a)，这里调用了两次拷贝构造函数。第一次，参数按值传递，使用拷贝构造函数创建一个临时对象。第二次 return a，
按值返回，需要调用拷贝构造函数创建临时对象。
再来看A b=function(a)，这里function(a)构建出了一个临时对象tmp,然后执行A b=tmp，进行构造对象b,这里不属于赋值的范畴，
理由：赋值是以构造好对象的行为。这里仍然属于用一个已存在的对象构造另外一个对象。故执行拷贝构造函数。
这里可以插入一句如果改成A b=function(a)+function(c); 在进行构造b的时候，可能编译器会进行优化，不会调用拷贝构造函数。
将临时对象的地址给了b.
3定义个空类，编译器会默认产生哪些成员函数；
class Empty{
public:
Empty();//缺省构造函数
Empty(const Empty &);//拷贝构造函数
~Empty();//析构函数
Empty & operator =(const Empty &);//赋值运算符
Empty * operator &();//取地址运算符
const Empty * operator &() const;//取地址运算符 const
};
因此会有，默认构造函数，拷贝构造函数，析构函数，赋值运算符，取址运算符(一个const 一个非const)
---------------------------------------------------------------------------------------------------------------------------------------------------
这里还是进行补充下拷贝构造函数，当用一个对象来初始化另一个对象，编译器会自动生成并调用拷贝构造函数 类似上面的A b=function(a)。这里跟赋值操作符不同
一般情况，如果是我们类的设计者并没有自己定义拷贝构造函数。隐式的复制构造函数是按值进行复制的，因此对于有指针成员的类就有个很致命的问题。
比如s.ptr=s1.ptr.通过执行这句话之后，两个指针指向同一块内存地址。执行完后，s1对象调用析构函数，则ptr指向的内存区域将被释放，那么另外一个指针将无内存可以指。
因此有必要我们用户自己定义复制构造函数。后续我们谈到的智能指针类会解决该问题
如果这里使用A b;
b=function(a);此处则会调用赋值运算符。
对于一个类，其构造函数的第一个参数是形如：x& ; const x& ;volatile x&; const volatile x&;且没有其他参数或者其他参数有默认值。那么这个函数是拷贝构造函数。
而对于A(A a){}这会导致无限调用拷贝构造函数的。必须为引用，因为拷贝构造函数一旦按值传入，就会调用拷贝构造函数。这样就无限制的调用拷贝构造函数了。而且编译器是编译不通过
------------------------------------------------------------------------------------------------------------------------------------------------------
按值传入，const引用，类型转换都会带来临时对象的产生
4关于在c++中使用memset(this,0,sizeof(A));
该函数的功能就是将类A全部清空为0，一般如果该类定义了虚函数，每个类都会有个不可见的指针成员虚函数指针，被构造函数初始化后，该指针指向的是一个虚函数表。
一旦置为0，则也将那指针置为0了。当用户调用虚函数时，虚函数是无法正常调用的。
关于new delete.
当我们使用delete p; 其源码会执行这样的操作:(假设类为A)
if(p!=NULL){
p->~A();//直接调用析构函数
operator delete( p);//内存释放语句
}
因此我们不妨可以将new看成构造函数，delete看成析构函数。
另外我们处于编码的习惯。在进行delete的时候我们一般会进行条件判断
if(p!=NULL){
delete p;
p=NULL;
}//这样我们调用delete后，记得将p置为NULL，这样就使得我们的p就不能继续使用。
5我们实现一个简单的智能指针类
class I_Pointer{
private:
int *p;
int ref_count;//计数作用
/*将构造函数设置为private,静止用户在类外通过这个构造函数产生类的实例*/
I_Pointer(int *ptr):p(ptr),ref_count(1){}
~I_Pointer(){
cout<<"~I_Pointer()"<<endl;
}
friend class Has_Ptr;
};
class Has_Ptr{
private:
I_Pointer *ptr;
void add_ref(){
cout<<"add reference count"<<endl;
++ptr->ref_count;
}
void release_ref_count(){
--ptr->ref_count;
cout<<"release_ref_count"<<endl;
if(ptr->ref_count==0){
free_mem();
}
}
void free_mem(){
delete ptr;
ptr=NULL;
cout<<"free_mem"<<endl;
}
public:
Has_Ptr(int *p) : ptr(new I_Pointer(p)){
}
~Has_Ptr(){
release_ref_count();
cout<<"~Has_Ptr"<<endl;
}
Has_Ptr(const Has_Ptr &hrs){
memcpy(this,&hrs,sizeof(hrs));
add_ref();
}
Has_Ptr& operator =(const Has_Ptr &hrs){
++hrs.ptr->ref_count;
release_ref_count();
memcpy(this,&hrs,sizeof(hrs));
return *this;
}
void set_ptr(int *p){
if(p!=ptr->p){
ptr->p=p;
}
}
int *get_ptr(){
return ptr->p;
}
};
当一个类的成员里面有指针的时候，使用默认拷贝构造函数的时候就会造成多个对象管理同一块内存。这样带来的后果就是，如果任意一个对象释放了这一块内存，那么其他对象来操作这块内存就会发生预料不到的结果。
Has_Ptr这个类其实是想保存int *p这个指针，为了避免悬浮指针的出现，我们使用了I_Pointer这个类把该指针包装了，因此在Has_Ptr这个类的接口中是不会出现I_Pointer的，只会出现int *.另外我们可以发现在I_Pointer中，我们将其构造函数设定为private，意在不允许在外部构造，只能在frend类中构造，I_Pointer就是专门为Has_Pointer服务的。
拷贝构造函数，赋值，析构 此为复制控制三剑客，切记。
6，快速排序的源码
#define MAX_SIZE 20
typedef struct _SqList{
int r[MAX_SIZE];
int length;
}SqList;
SqList* initSqList(SqList *lpt){
if(lpt==NULL){
lpt=new SqList;
}
for(int i=0;i<MAX_SIZE;i++){
lpt->r[i]=0;
}
lpt->length=0;
return lpt;
}
void creatSqList(SqList *lpt){
cin>>lpt->length;
if(lpt->length>20){
cout<<"out of range error"<<endl;
return;
}
for(int i=1;i<=lpt->length;i++){
cin>>lpt->r[i];
}
}
void print(SqList *lpt){
for(int i=1;i<=lpt->length;i++){
cout<<lpt->r[i]<<"\t";
}
cout<<endl;
}
/*快速排序*/
void quickSort(SqList *lpt,int beg,int end,int key){
int initBeg=beg;
int initEnd=end;
while(beg<end){
for(int i=end;lpt->r[i]>lpt->r[key];i--){
--end;
}
if(end!=key){
swap(lpt->r[i],lpt->r[key]);
key=i;
}
for(i=beg;lpt->r[i]<lpt->r[key];i++){
beg++;
}
if(beg!=key){
swap(lpt->r[i],lpt->r[key]);
key=i;
}
}
if(key-initBeg>1){
quickSort(lpt,initBeg,key-1,initBeg);
}
if(initEnd-key>1){
quickSort(lpt,key+1,initEnd,key+1);
}
}
7关于最后一道数学题。
10瓶药，每瓶药里面有1000个药片，每块药片重100mg，现在是有几个药瓶里面的药片比正常值重了10mg，我们如何找到那几瓶异常的药瓶。
此题虽为逻辑题，实则就是一个数学题，思路：给对应的10瓶一一编号1,2,3，..10,，然后我们分别在编号1中取1片，2号瓶取2片
最终我们取的片数按编号来为:1,2,3,5,8,13,21...
做到这里我想大家都明白了。(1+2+3+5+8..)*100+x*10，我们用天平得到这些总的药片之和。如果都是正常的x肯定为0，但是如果不正常，那我们得到x，看他等于多少，推出药瓶的编号。这里的和对应的编号是唯一的。