C++大杂烩（一）

最新推荐文章于 2024-07-10 17:36:44 发布

睡觉打呼噜

最新推荐文章于 2024-07-10 17:36:44 发布

阅读量236

点赞数

分类专栏： C++大杂烩

本文链接：https://blog.csdn.net/u010352111/article/details/53355965

版权

C++大杂烩专栏收录该内容

14 篇文章 0 订阅

订阅专栏

搜罗到的觉得有用的东西

C++面试题
1.

int func(int x){
     int countx = 0;
     while(x){
           countx ++;
           x = x&(x-1);
      }
     return countx;
 }

x&(x-1) 从右边将最右边的一个1变为0。

什么是“引用”？申明和使用“引用”要注意哪些问题？

答：引用就是某个目标变量的“别名”（alias），对应用的操作与对变量直接操作效果完全相同。==申明一个引用的时候，切记要对其进行初始化==。引用声明完毕后，相当于目标变量名有两个名称，即该目标原名称和引用名，不能再把该引用名作为其他变量名的别名。声明一个引用，不是新定义了一个变量，它只表示该引用名是目标变量名的一个别名，它本身不是一种数据类型，因此引用本身不占存储单元，系统也不给引用分配存储单元。不能建立数组的引用。

将“引用”作为函数参数有哪些特点？

（1）==传递引用给函数与传递指针的效果是一样的==。这时，被调函数的形参就成为原来主调函数中的实参变量或对象的一个别名来使用，所以在被调函数中对形参变量的操作就是对其相应的目标对象（在主调函数中）的操作。

（2）使用引用传递函数的参数，在内存中并没有产生实参的副本，它是直接对实参操作；而使用一般变量传递函数的参数，当发生函数调用时，需要给形参分配存储单元，形参变量是实参变量的副本；如果传递的是对象，还将调用拷贝构造函数。因此，当参数传递的数据较大时，==用引用比用一般变量传递参数的效率和所占空间都好。==

（3）使用指针作为函数的参数虽然也能达到与使用引用的效果，但是，在被调函数中同样要给形参分配存储单元，且需要重复使用”*指针变量名” 的形式进行运算，这很容易产生错误且程序的阅读性较差；另一方面，在主调函数的调用点处，必须用变量的地址作为实参。而引用更容易使用，更清晰。
将“引用”作为函数返回值类型的格式、好处和需要遵守的规则？

格式：类型标识符 &函数名（形参列表及类型说明）{ //函数体 }好处：在内存中不产生被返回值的副本；（注意：正是因为这点原因，所以返回一个局部变量的引用是不可取的。因为随着该局部变量生存期的结束，相应的引用也会失效，产生runtime error！
“引用”与多态的关系？

引用是除指针外另一个可以产生多态效果的手段。这意味着，一个基类的引用可以指向它的派生类实例。
结构与联合有和区别？
1. 结构和联合都是由多个不同的数据类型成员组成，但在任何同一时刻，联合中只存放了一个被选中的成员（所有成员共用一块地址空间），而结构的所有成员都存在（不同成员的存放地址不同）。
2. 对于联合的不同成员赋值，将会对其它成员重写，原来成员的值就不存在了，而对于结构的不同成员赋值是互不影响的。
已知strcpy的函数原型：char *strcpy（char *strDest， const char *strSrc）其中strDest 是目的字符串，strSrc 是源字符串。不调用C++/C 的字符串库函数，请编写函数 strcpy.

char *strcpy(char *strDest, const char *strSrc)
{
    const char *tempstrSrc = strSrc ;//保存头指针
    if ( strDest == NULL || tempstrSrc == NULL)
        return NULL ;
    if ( strDest == tempstrSrc)
        return strDest ;
    char *tempptr = strDest ;
    while ( (*tempptr++ = *tempstrSrc++)!='\0');
    cout<<strDest<<endl;
    cout<<strSrc<<endl;
    return strDest ;
}
int main(int argc, const char * argv[])
{
    char strDest[10];
    char *strSrc="123456789";
    cout<<strSrc<<endl;
    strcpy(strDest,strSrc);
    cout<<strDest<<endl;
    cout<<strSrc<<endl;
}

为了使指针位置不变，需要两个临时指针来起到移位址的效果。当源串的长度大于开辟空间的长度L-1时，可能会覆盖内存中的地址，在codeblock中，覆盖掉strSrc的地址，导致strSrc寻址出错。

已知String类定义如下：
class String {
 public:
 String(const char *str = NULL); // 通用构造函数
 String(const String &another); // 拷贝构造函数
 ~ String(); // 析构函数
String & operater =(const String &rhs);//赋值函数
private:
 char *m_data; // 用于保存字符串
 };
 的实现

 String::String(const char *str){
    if ( str == NULL ) //strlen在参数为NULL时会抛异常才会有这步判断
    {
        m_data = new char[1] ;
        m_data[0] = '\0' ;
    }
    else
    {
        m_data = new char[strlen(str) + 1];
        strcpy(m_data,str);
    }
}
String::String(const String &another){
    m_data = new char[strlen(another.m_data) + 1];
    strcpy(m_data,other.m_data);
}
String& String::operator =(const String &rhs){
    if ( this == &rhs)
        return *this ;
    delete []m_data; //删除原来的数据，新开一块内存
    m_data = new char[strlen(rhs.m_data) + 1];
    strcpy(m_data,rhs.m_data);
    return *this ;
}
String::~String(){
    delete []m_data ;
}

==先判断是否为空，若写=重载，先删除在申请空间。同时记得确认空间申请是否成功。==

面向对象的三个基本特征，并简单叙述之？
1. 封装：将客观事物抽象成类，每个类对自身的数据和方法实行protection（private， protected，public）
2. 继承：广义的继承有三种实现形式：实现继承（指使用基类的属性和方法而无需额外编码的能力）、可视继承（子窗体使用父窗体的外观和实现代码）、接口继承（仅使用属性和方法，实现滞后到子类实现）。前两种（类继承）和后一种（对象组合=>接口继承以及纯虚函数）构成了功能复用的两种方式。
3. 多态：是将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。
重载（overload）和重写（overried，有的书也叫做“覆盖”）的区别？

常考的题目。从定义上来说：重载：是指允许存在多个同名函数，而这些函数的参数表不同（或许参数个数不同，或许参数类型不同，或许两者都不同）。

重写：是指子类重新定义复类虚函数的方法。

从实现原理上来说：重载：编译器根据函数不同的参数表，对同名函数的名称做修饰，然后这些同名函数就成了不同的函数（至少对于编译器来说是这样的）。如，有两个同名函数：function func（p：integer）：integer；和function func（p：string）：integer；。那么编译器做过修饰后的函数名称可能是这样的：int_func、str_func.对于这两个函数的调用，在编译器间就已经确定了，是静态的。也就是说，它们的地址在编译期就绑定了（早绑定），因此，重载和多态无关！

重写：和多态真正相关。当子类重新定义了父类的虚函数后，父类指针根据赋给它的不同的子类指针，动态的调用属于子类的该函数，这样的函数调用在编译期间是无法确定的（调用的子类的虚函数的地址无法给出）。因此，这样的函数地址是在运行期绑定的（晚绑定）。