【筆試題精選】_4

下面代碼是否有錯誤？若是有錯，錯在哪裏？

struct Test
{
    Test() {};
    Test(int i){}
    void func(){}
};

int main()
{
    Test t1(1);
    Test t2();
    t1.func();
    t2.func();
}

答案：

1. Test t2();  ==>  Test t2;
warning: empty parentheses interpreted as a function declaration

2. t2.func();  ==>
error: base of member reference is a function; perhaps you meant to call it with no arguments?

3. int main() 缺乏返回值
C++ 編譯器須要兼容 C 編譯器，編譯過現有的 C 代碼，所以沒有報錯

---

下面的代碼輸出什麼？爲何？

class Test
{
private:
    int m_i;
    int m_j;
public:
    Test(int v) : m_j(v), m_i(m_j)
    {
    }
    
    int getI()
    {
        return m_i;
    }
    
    int getJ()
    {
        return m_j;
    }
};

int main()
{
    Test t1(1);
    Test t2(2);
    
    cout << t1.getI() << " " << t1.getJ() << endl;
    cout << t2.getI() << " " << t2.getJ() << endl;
}

輸出：

隨機數， 1
隨機數， 2

說明：

成員的初始化順序與成員的聲明順序相同
成員的初始化順序與初始化列表中的位置無關

本題中成員變量在未初始化前存儲的是隨機數

參考：
初始化列表的使用

---

下面的代碼輸出什麼？爲何？

#include <iostream>

using namespace std;

class Test
{
private:
    int m_i;
    int m_j;
public:
    Test()
    {
        cout << "Test()" << endl;
    }
    
    Test(int v)
    {
        cout << "Test(int v)" << endl;
    } 
    
    Test(const Test& v)
    {
        cout << "Test(const Test& v)" << endl;
    }
    
    ~Test()
    {
        cout << "~Test()" << endl;
    }
};

Test Play(Test t)
{
    return t;
}

int main()
{
    Test m_t = Play(5);
}

輸出：

g++ test.cpp -fno-elide-constructors 禁止編譯器作任何優化

Test(int v)
Test(const Test& v)
Test(const Test& v)
Test(const Test& v)
~Test()
~Test()
~Test()
~Test()

Which virtual fucntion re-declaration of the Derived class are correct ?

A. Base* Base::copy(Base*);
   Base* Derived::copy(Derived*);

B. Base* Base::copy(Base*);
   Derived* Derived::copy(Base*);

C. int Base::count();
   int Derived::count();

D. void Base::func(Base*)const;
   void Derived::func(Base*);

答案：【C】
說明：

多態發生的條件：發生在派生類與基類之間；函數簽名必須徹底一致；

---

下面的程序輸出什麼？爲何？

class Base
{
public:
    virtual void func()
    {
        cout << "Base::func()" << endl;
    }
};

class Child:public Base
{
public:
    void func()
    {
        cout << "Child::func()" << endl;
    }
};

int main()
{
    Base* pb = new Base();
    pb->func();
    Child* pc = (Child*)pb;  // 注意這裏！！！
    pc->func();
    delete pc;
    
    pb = new Child();
    pb->func();
    pc = (Child*)pb;
    pc->func();
}

輸出：

cout << "Base::func()" << endl;   // 正常調用
cout << "Base::func()" << endl;
cout << "Child::func()" << endl;  // 多態調用
cout << "Child::func()" << endl;  // 正常調用

說明：

Child* pc = (Child*)pb;  ==> 子類對象指針指向父類對象，這是及其危險的！！

但是爲何沒有發生程序錯誤呢？
由於有虛函數表的存在，不管是子類對象指針仍是父類對象指針指向父類對象，都會發生相同的查找過程

當 func 不是虛函數時，就不會發生虛函數表的查找過程，此時必定會發生程序崩潰

參考：
C++對象模型分析

---

A C++ develoer wants to handle a static_cast<char*>() operation for the String class shown below. Which of the following options are valid declarations that will accomplish task ?

class String
{
public:
// ...
// declaration goes here
}

A. char* operator char*();
B. operator char*();
C. char* operator();
D. char* operator String();

答案：【B】

---

如下兩種狀況：（1）new 一個 10 個整型變量的數組 （2）分 10 次 new 一個整型變量。 哪一個佔用的空間更大？

A. 1
B. 2
C. 同樣多
D. 沒法肯定

答案：【B】
說明：

---

下面程序輸出什麼？

int main()
{
    int v[2][10] = 
    {
        { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
        {11, 12, 13, 14, 15, 16, 17, 18, 19, 20}
    }
    
    int (*a)[8] = (int(*)[8])v;
    
    cout << **a << endl;
    cout << **(a + 1) << endl;
    cout << *(*a + 1) << endl;
    cout << *(a[0] + 1) << endl;
    cout << *a[1] << endl;
}

輸出：

1
9
2
2
9

參考：
多維數組和多維指針

---

下面的程序輸出什麼？爲何？

class Base
{
public:
    int a;
    
    Base() 
    { 
        a = 1; 
    }
    
    void println() 
    {
        cout << a << endl;
    }
};

class Child : public Base
{
public：
    int a;
    
    Child() 
    {
        a = 2;
    }
};

int main()
{
    Child c;
    c.println();
    cout << c.a << endl;
}

輸出：

1
2

說明：

c.println(); ==> 父類中的 printlin 被調用，因爲做用域， 父類中的 a 被訪問

c.a ==> 發生同名覆蓋

參考：
父子間的衝突

---

用 C/C++ 語言實現一個存儲整型數據的棧結構

要求實現如下功能：
1. 入棧操做 push
2. 出棧操做 pop
3. 棧大小操做 size
4. 棧中最小元素 min

class IntStack
{
private:
    list<int> m_stack;
    list<int> m_cmin;

public:
    void push(int v);
    int pop();
    int top();
    int size();
    int min();
};

void IntStack::push(int v)
{
    m_stack.push_front(v);

    if( m_cmin.size() != 0 )
    {
        if( v < m_cmin.front() )
        {
            m_cmin.push_front(v);
        }
        else
        {
            m_cmin.push_front(m_cmin.front());
        }
    }
    else
    {
        m_cmin.push_front(v);
    }
}

int IntStack::pop()
{
    int ret = m_stack.front();

    m_stack.pop_front();
    m_cmin.pop_front();

    return ret;
}

int IntStack::top()
{
    return m_stack.front();
}

int IntStack::size()
{
    return m_stack.size();
}

int IntStack::min()
{
    return m_cmin.front();
}

---

編程實現二叉樹的相等比較，當二叉樹每一個節點的值對應相等時，二叉樹相等，不然不相等

struct BTreeNode
{
    int v;
    BTreeNode* left;
    BTreeNode* right;
};

函數原型：
bool BTreeCompare(BTreeNode* b1, BTreeNode* b2);

深度優先：

bool BTreeCompare(BTreeNode* b1, BTreeNode* b2)
{
    bool ret = false;

    if( (b1 != NULL) && (b2 != NULL) )
    {
        ret = (b1->v == b2->v) && BTreeCompare(b1->left, b2->left) && BTreeCompare(b1->right, b2->right);
    }

    if( (b1 == NULL) && (b2 == NULL) )
    {
        ret = true;
    }

    return ret;
}

廣度優先：

bool BTreeCompareEx(BTreeNode* b1, BTreeNode* b2)
{
    bool ret = true;
    list<BTreeNode*> l1;
    list<BTreeNode*> l2;

    l1.push_back(b1);
    l2.push_back(b2);

    while( ret && l1.size() && l2.size() )
    {
        BTreeNode* n1 = l1.front();
        BTreeNode* n2 = l2.front();

        l1.pop_front();
        l2.pop_front();

        if( (n1 != NULL) && (n2 != NULL) )
        {
            ret = (n1->v == n2->v);

            l1.push_back(n1->left);
            l1.push_back(n1->right);

            l2.push_back(n1->left);
            l2.push_back(n2->right);
        }
        else if( (n1 == NULL) && (n2 != NULL) )
        {
            ret = false;
        }
        if( (n1 != NULL) && (n2 == NULL) )
        {
            ret = false;
        }
    }

    return ret && (l1.size() == 0) && (l2.size() == 0);
}