C++--臨時對象與經典問題

一.臨時對象

Q:下面的程序將輸出什么？為什么？

#include <iostream>
using namespace std;
class Test
{
    int mi;
public:
    Test(int i)
    {
        mi=i;
    }
    Test()
    {
        Test(0);
    }
    void print()
    {
        cout<<"mi="<<mi<<endl;
    }
};
int main()
{
    Test t;
    t.print();

    return 0;
}

由上面的程序可以得出，該程序的本意在Test()中以0作為參數調用Test(int),t同時將mi初始值設置為0，并將其打印出來
運行結果如圖所示

由運行結果得知，mi的初始值為隨機值，從這里得出一個疑問，構造函數是一個特殊的函數，是否可以直接調用？是否可以在構造函數中調用構造函數？直接調用構造函數的行為是什么？
答案--直接調用構造函數將產生一個臨時對象，臨時對象的生命周期只有一條語句的時間，臨時對象的作用域只在一條語句中，臨時對象是C++中值得警惕的灰色地帶
解決方法代碼如下

#include <iostream>
using namespace std;
class Test
{
    int mi;
    void init(int i)
    {
        mi=i;
    }
public:
    Test(int i)
    {
        init(i);
    }
    Test()
    {
        init(0);
    }
    void print()
    {
        cout<<"mi="<<mi<<endl;
    }
};
int main()
{
    Test t;
    t.print();

    return 0;
}

運行結果

可以看到，當定義了一個init函數并調用之后，mi初始值為0
編譯器的行為--現代C++編譯器在不影響最終執行結果的前提下，會盡力減少臨時對象的產生
代碼示例

#include <stdio.h>

class Test
{
    int mi;
public:
    Test(int i)
    {
        printf("Test(int i) : %d\n", i);
        mi = i;
    }
    Test(const Test& t)
    {
        printf("Test(const Test& t) : %d\n", t.mi);
        mi = t.mi;
    }
    Test()
    {
        printf("Test()\n");
        mi = 0;
    }
    int print()
    {
        printf("mi = %d\n", mi);
    }
    ~Test()
    {
        printf("~Test()\n");
    }
};

Test func()
{
    return Test(20);
}

int main()
{
    Test t = Test(10); // ==> Test t = 10;
    Test tt = func();  // ==> Test tt = Test(20); ==> Test tt = 20;

    t.print();
    tt.print();

    return 0;
}

猜想：生成臨時對象，用臨時對象初始化t，調用拷貝構造函數
運行結果

小結
1.直接調用構造函數將產生一個臨時對象
2.臨時對象是性能的瓶頸，也是Bug的來源之一
3.實際工程開發需要人為ide避開臨時對象

二.經典問題

A.關于析構的疑問
a.單個對象創建時構造函數的調用順序
1.調用父類的構造順序
2.調用成員變量的構造函數--調用順序與聲明順序相同
3.調用類自身的構造函數--析構函數與對應構造函數的調用順序相反

1.第一種情況--多個對象析構時(析構順序與構造順序相反)
代碼示例

#include <iostream>
using namespace std;

class Member
{
    const char* ms;
public:
    Member(const char* s)
    {
        cout<<"Member(const char* s):"<< s<<endl;;

        ms = s;
    }
    ~Member()
    {
        cout<<"~Member():" <<ms<<endl;;
    }
};

class Test
{
    Member mA;
    Member mB;
public:
    Test() : mB("mB"), mA("mA")
    {
        cout<<"Test()"<<endl;
    }
    ~Test()
    {
        cout<<"~Test()"<<endl;
    }
};

Member gA("gA");

int main()
{
    Test t;  
    return 0;
}

代碼分析:先對定義的Member gA("gA")進行構造，再對Test類中的成員變量的構造函數，最后對自身的構造函數進行調用，析構順序與構造順序相反
運行結果

析構：對于棧對象和全局對象，類似于入棧于出棧的順序，最后構造的對象被最先析構，堆對象的析構發生在使用delete的時候，于delete的使用順序相關
B.const關鍵字能否修飾類的對象？如果可以，有什么特性?
1.const關鍵字能夠修飾對象
2.const修飾的對象為只讀對象
3.只讀對象的成員變量不允許被改變
4.只讀對象是編譯階段的概念，運行時無效
C++中的const成員函數
1.const對象只能調用const的成員函數
2.const成員函數中只能調用const成員函數
3.const成員函數中不能直接改寫成員變量的值
const成員函數的定義：Type ClassName::function(Type p)const--類中的函數聲明與實際函數定義都必須帶const關鍵字
代碼示例

#include <iostream>
using namespace std;

class Test
{
    int mi;
public:
      int mj;
    Test(int i);
    Test(const Test& t);
    int getMi()const;
};

Test::Test(int i)
{
    mi = i;
}

Test::Test(const Test& t)
{

}

int Test::getMi()const
{
    return mi;
}

int main()
{
    const Test t(1);
    t.mj=1000;
    return 0;
}

由程序可得，const修飾了對象t,而下一步又對t.mj進行賦值，這時程序會報錯，因為是只讀的

這時對程序進行修改

程序運行的結果如圖所示
出現該問題的原因是const成員函數中只能調用const成員函數，需要在getMi加const來進行修飾
進行修改以及運行結果圖

小結
1.對象的析構順序與構造順序相反
2.const關鍵字能夠修飾對象，得到只讀對象
3.只讀對象只能調用const成員函數