C++面试题

1.用 C++写个程序，判断一个操作系统是16位还是32位的？不能用sizeof()函数。

方法一、利用unsigned int类型变量的最大值，int类型在16位系统中占2个字节，

在32位系统中占4个字节。

#include <iostream>
using namespace std;

int main(){
    unsigned int a=~0;
    cout<<a<<endl;
    if(a>65536){
        cout<<"32 bit"<<endl;
    }
    else{
        cout<<"16 bit"<<endl;
    }
    return 0;
}

编译后，在32位系统中执行的结果如下：

4294967295

32 bit

2.当一个类A 中没有生命任何成员变量与成员函数，这时sizeof（A）的值是多少，如果不是零，请解释一下。

sizeof（A）=1。

一个空类对象的大小是1byte。这是被编译器安插进去的一个字节，这样就使得这个空类的不同实体（object）得以在内存中配置独一无二的地址。

也就是说这个char是用来标识类的不同对象的。

/*nullclass.cpp*/
#include <iostream>
using namespace std;

class A{
};
int main(){
    cout<<sizeof(A)<<endl;
    A a,b;
    cout<<&a<<endl;
    cout<<&b<<endl;
    return 0;
}

编译后，在32位系统中执行的结果如下：

1
0xbfd2783e

0xbfd2783f

3. 编写类string的构造函数、析构函数和赋值函数

#include<iostream>  
using namespace std;  
class String  
{  
public:  
    String(const char *str=NULL);            //普通构造函数  
    String(const String &other);             //复制构造函数  
    ~String(void);                           //析构函数  
    String & operator=(const String &other);//赋值函数  
private:  
    char *m_String;                        //私有成员，保存字符串  
};  
String::String(const char *str)  
{  
    cout<<"普通构造函数"<<endl;  
    if(str==NULL)                         //如果str为空，存空字符串  
    {  
        m_String=new char[1];             //分配一个字节  
        *m_String='\0';                  //将之赋值为字符串结束符  
    }  
    else  
    {  
        m_String=new char[strlen(str)+1]; //分配空间容纳str内容  
        strcpy(m_String,str);             //赋值str到私有成员   
    }  
}  
String::String(const String &other)  
{  
    cout<<"复制构造函数"<<endl;  
    m_String=new char[strlen(other.m_String)+1];  
    strcpy(m_String,other.m_String);  
}  
String::~String(void)  
{  
    cout<<"析构函数"<<endl;  
    if(m_String!=NULL)                    //如果m_String 不为NULL，释放堆内存  
    {  
        delete [] m_String;              //释放后置为NULL  
        m_String=NULL;  
    }  
}  
String & String::operator =(const String &other)  
{  
    cout<<"赋值函数"<<endl;  
    if(this==&other)                   //如果对象与other是同一个对象  
    {  
        return *this;                  //直接返回本身  
    }  
    delete [] m_String;  
    m_String=new char[strlen(other.m_String)+1];  
    strcpy(m_String,other.m_String);  
    return *this;  
}  
int main()  
{  
    String a("hello");           //调用普通构造函数  
    String b("word");            //调用普通构造函数  
    String c(a);                 //调用复制构造函数  
    c=b;                         //调用赋值函数  
    return 0;  
}  

说明：
（1）普通构造函数：这里判断了传入的参数是否为NULL，如果是NULL，初始化一个字节的空字符串（包括结束符'\0'）;如果不是，分配足够大小长度的堆内存来保存字符串。
（2）复制构造：只是分配足够小长度的堆内存来保存字符串。
（3）析构函数：如果类私有成员m_String不为NULL，释放m_String指向的堆内存，并且为了避免产生野指针，将m_String赋值为NULL。

（4）赋值函数：首先判断当前对象与引用传递对象是否是同一个对象，如果是，不做操作，直接返回；否则，先释放当前对象的堆内存，然后分配足够大小长度的堆内存复制字符串。

3.内存分配的形式以及他们的区别

从静态存储区域分配

内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在。例如全局变量，static 变量（包括静态全局变量和静态局部变量）。

在栈上创建

在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集。

从堆上分配，亦称动态内存分配

程序在运行的时候用malloc 或new 申请任意多少的内存，程序员自己负责在何时用free 或delete 释放内存。动态内存的生存期由我们决定，使用非常灵活，但问题也最多。