12-4-13关于方正的笔试

最新推荐文章于 2024-06-16 15:02:22 发布

database_system

最新推荐文章于 2024-06-16 15:02:22 发布

阅读量982

点赞数

文章标签： function delete 编译器 null class reference

本文链接：https://blog.csdn.net/database_system/article/details/7456416

版权

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

}