筆試常見試題

1、c++類的構造和析構？

      構造函數： 1、定義與類名相同的成員函數叫構造函數

                        2、構造函數在定義時可以有參數

                       3、沒有任何返回類型的聲明

     析構函數：1、清理對象的函數，沒有參數也沒有任何返回類型的聲明

                      2、在對象銷燬時自動調用

先創建的對象後析構，類沒有提供構造函數c++編譯器會自動給你提供一個默認的構造函數，類沒有提供拷貝構造函數，c++會提供一個默認的拷貝構造函數，

拷貝函數調用時機：

1、Test(const Test &obj)

    Test t1(1,2);

    Test t2(3,4);

    Test  t3 =t1;//用t1來初始化t3 會調用拷貝構造函數

    t2 =t1；//用t1給t2賦值，不會調用拷貝構造函數會調用 operator =（）

  賦值操作和初始化是兩個不同的概念。

2、第二種調用時機

    Test t1(1,2);

   Test t2(t1);//用t1對象初始化t2對象 時會調用拷貝構造函數

3、第三種調用時機

  當類的對象當作實參傳給形參時，調用拷貝構造函數

   Test t1（1，2）；

  void Gets（Test t）;

 Gets(t1);//會調用拷貝構造函數

4、第四種調用時機

 void play （）

{   

     Test t1；

    t1 =g（）；//用返回的匿名對象賦值給另外一個同類型的對象，那麼匿名對象被析構，

   Test t2 = g();

  //用返回的匿名對象，來初始化另外一個同類型的對象，那麼匿名對象會直接轉成新的對象，會調用拷貝構造函數，匿名對象不會析構掉

}

Test g()

{

    Test  a(1,2);

    return a;//返回匿名對象

}

構造函數執行順序：先構造的後析構，後構造的先析構，它相當於一個棧，先進後出。

2、delete和delete[]的區別

new 和 delete是操作符，free和malloc是c/c++的標準函數庫

delete 釋放new分配的單個對象指針指向的內存
delete[] 釋放new分配的對象數組指針指向的內存

C++告訴我們在回收用 new 分配的單個對象的內存空間的時候用 delete，回收用 new[] 分配的一組對象的內存空間的時候用 delete[]。 

 new[] 和 delete[]，其中又分爲兩種情況：(1) 爲基本數據類型分配和回收空間；(2) 爲自定義類型分配和回收空間。 基本類型的對象沒有析構函數，所以回收基本類型組成的數組空間用 delete 和 delete[] 都是應該可以的；但是對於類對象數組，只能用 delete[]。對於 new 的單個對象，只能用 delete 不能用 delete[] 回收空間。

3、指針和引用的區別

  （1）、指針可以賦予空值，引用不可以賦值空值且當被創建的時候必須初始化，

  （2）、指針的指向可以改變，當應用初始化後不可以改變，

  （3）、sizeof指針 得到的爲指針本身的大小，在32位系統中爲4個字節，sizeof引用的字節大小爲引用對象的大小

 （4）、指針有多級指針，引用只有一級

  （5）、指針和引用的自增++運算意義不一樣

4、代碼定義了一個常量指針和一個指向常量的指針，問2個指針有什麼區別？

  常量指針是指指針本身是常量，指向的對象是變量

  指向常量的指針是指：指針本身是變量，指向的對象是常量

5、string 類的成員函數補全，包括3種構造函數和一種=的運算符重載。

#include <iostream>  
#include <string.h>  
#include "String.h"  
  
using namespace std;  
  
String::String()  
{  
    str_ = new char['\0'];  
    cout << "default construct String!" << endl;  
}  
  
String::String(char *str)  
{  
    cout << "construct String!" << endl;  
  
    int len = strlen(str) + 1;  
    str_ = new char[len];  
    memset(str_, 0, len);  
    strcpy(str_, str)  
}  
  
String::String(const String& other)  
{  
    int len = strlen(other.str_) + 1;  
    str_ = new char[len];  
    memset(str_, 0, len);  
    strcpy(str_, other.str_);  
}  
  
String& String::operator=(const String& other)  
{  
    if(this == &other)  
    {  
        return *this;  
    }  
      
    int len = strlen(other.str_) + 1;  
    delete [] str_;  
    str_ = new char[len];  
    memset(str_, 0, len);  
    strcpy(str_, other.str_);  
  
    return *this;  
}  
  
String& String::operator=(char *str)  
{  
    delete [] str_;  
    int len = strlen(str) + 1;  
    str_ = new char[len];  
    memset(str_, 0, len);  
    strcpy(str_, str);  
  
    return *this;  
}  
  
char& String::operator[](unsigned int index)  
{  
    //return str_[index];  
    return const_cast<char&>(static_cast<const String&>(*this)[index]);  
}  
  
const char& String::operator[](unsigned int index) const  
{  
    return str_[index];  
}  
  
String operator+(const String& s1, const String& s2)  
{  
#if 0  
    int len = strlen(s1.str_) + strlen(s2.str_) + 1;  
    char *newptr = new char[len];  
    memset(newptr, 0, len);  
    strcpy(newptr, s1.str_);  
    strcat(newptr, s2.str_);  
    String tmp(newptr);  
#endif  
  
    String tmp(s1);  
  
    tmp += s2;  
  
    return tmp;  
}  
  
String& String::operator+=(const String& s)  
{  
    int len = strlen(s.str_) + strlen(str_) + 1;  
  
    char *newptr = new char[len];  
    memset(newptr, 0, len);  
    strcpy(newptr, str_);  
    strcat(newptr, s.str_);  
    String tmp(newptr);  
      
    delete [] str_;  
    str_ = new char[len];  
    strcpy(str_, newptr);  
  
    return *this;  
}  
  
ostream& operator<<(ostream& out, const String& s)  
{  
    out << s.str_;  
    return out;  
}  
  
istream& operator>>(istream& in, String& s)  
{  
    char buffer[4096];  
  
    in >> buffer;  
    s.str_ = buffer;  
  
    return in;  
}  
  
String::~String()  
{  
    cout << "destroy String!" << endl;  
}  
  
void String::Display()  
{  
    cout << "str = " << str_ << endl;  
}  

#include <iostream>  
#include "String.h"  
  
using namespace std;  
  
int main()  
{  
    String s1("hello");  
    s1.Display();  
  
    String s2(s1);  
    //String s2;  
    //s2.Display();  
#if 0  
    String s3;  
    s3 = s1;  
    //s3 = "hello";  
    s3.Display();  
//#endif  
  
    s1[1] = 'E';  
    s1.Display();  
#endif  
  
    String s3("world");  
#if 0  
    s3 += s1;  
    s3.Display();  
  
    cin >> s2;  
    cout << s2 << endl;  
#endif  
  
    s3 = s1 + s2;  
    s3.Display();  
  
    return 0;  
}  

#ifndef _STRING_H_  
#define _STRING_H_  
#endif  
#include <iostream>  
  
using namespace std;  
  
class String  
{  
public:  
    String();  
    String(char *str);  
    String(const String& other);  
    ~String();  
  
    String& operator=(char *str);  
    String& operator=(const String& other);  
  
    char& operator[](unsigned int index);  
    const char& operator[](unsigned int index) const;  
  
    friend String operator+(const String& s1, const String& s2);  
  
    String& operator+=(const String& s);  
  
    friend ostream& operator<<(ostream& out, const String& s);  
    friend istream& operator>>(istream& in, String& s);  
  
    void Display();  
  
private:  
    char *str_;  
};  

6、編號1-n的人圍成1圈，數到m的人站出來，直到所有人站出來，求站出來的人的序列（key:細節處理）

#include"stdafx.h"
#include<iostream>

struct ChainNode
{
    int data;
    ChainNode* next;
};

//編號爲1-n的人，數到m的人站出來，求站出來的人的序列(key:細節處理）
int main()
{
    int n, m;
    cin >> n >> m;


    //create circularList
    int len = n;
    ChainNode* headNode = new ChainNode;
    ChainNode* pNode = headNode;
    while (n--)
    {
        pNode->data = len - n;
        if (n)                            //不需要的不申請
        {
            pNode->next = new ChainNode;
            pNode = pNode->next;
        }
    }
    pNode->next = headNode;
    pNode = pNode->next;
    

    //print order
    int rest = len;
    while (rest)                          //用rest判斷而不用pNode判斷，鏈表是否爲空用指針無法判斷
    {
        int cot = m - 2; 
        while (cot--)
        {
            pNode = pNode->next;
        }
        cout << pNode->next->data << endl;
        ChainNode* tmp = pNode->next;
        pNode->next = pNode->next->next;
        delete tmp;
        rest--;
        pNode = pNode->next;
    }
    return 0;
}