c艸進階編程（1）

前排提示：此文并不適合初學者閱讀

目錄

替換#define

用const替換

用enum替換

用inline替換

constexpr及const的盡可能使用

不同檔案的static引數初始化順序

替換#define

用const替換

如果各位對編譯原理熟悉，應該知道什么是符號表，如果不懂，可以去翻翻，

我們都知道#define在預編譯階段就會被處理（通常情況下），因此在程式編譯程序中，如果出現錯誤，我們看到的報錯往往是#define后面的內容，本身符號不會顯示在錯誤提示欄中，這樣很容易造成困惑，因此我們經常用const替換define；有兩個特殊情況：

1. 指標-》常量指標常量或者直接string

   const char* const p="I love wqm"
   
   or
   
   const std::string p("I love wqm")
   

2. 類成員變數-》常量靜態成員變數：初始化可以在宣告式中賦予，定義式可以不帶任何東西,舊式編譯器不支持這種操作,只能在定義式中賦值，
   這樣就會導致一個問題：如果我們希望在nums陣列定義的時候使用這個常量，我們在外面定義，編譯器是無法通過的，因為它想堅持知道num的值，

   class test
   {
       static const num=5;
       int nums[num]
   }
   const int test::num;

用enum替換

在舊式編譯器中，如果不支持內部定義值，我們可以用enum代替,它與const有兩點區別：

1.其實enum更像define，因為不可以取地址，如果不希望有指標指向這個物件，推薦用enum，
2.不會多分配空間，不夠優秀的編譯器可能會給const分配額外的空間

class test
{
    enum{num=5};
    int nums[num]
}

用inline替換

宏定義的一個很大的有點就是可以定義簡單的函式，但是不會招致函式呼叫帶來的額外開銷，比如額外的堆疊呼叫，比如這個：

#define MY_MAX(a,b) f((a)>(b)?(a):(b))

但是其實這種寫法很傻，因為符號優先級我們必須對所有實參加上小括號，否則運行的時候可能會與宏左右的運算子提前運算導致達不到理想的結果，再比如說這種呼叫方式：

int a=5,b=0;
MY_MAX(++a,b);
My_MAX(++a,b+10);

如果傳入的本身就是一個帶運算子的數，很可能結果會與我們想法事與愿違，

我們可以用template inline函式替換簡單的函式

template<typename T>
inline void myMax(const T& a,const T& b)
{
    f(a>b?a:b);
}

這種方式就不用擔心多次求值，另一個優點是可以在類內實作，是有作用域的，而define無法定義作用域，

constexpr及const的盡可能使用

c++14版本進一步擴充了constexpr的使用，要求為傳入和輸出都是const，這兩者是有區別的，const可以表示字面值常量也可以表示只讀，而constexpr只能表示字面值常量，如果用constexpr作為函式前綴，編譯器就能大膽地優化，

需要額外強調的是，常量運算式和非常量運算式的計算時機不同，非常量運算式只能在程式運行階段計算出結果，但是常量運算式的計算往往發生在程式的編譯階段，這可以極大提高程式的執行效率，因為運算式只需要在編譯階段計算一次，節省了每次程式運行時都需要計算一次的時間，

但是值得注意的是，并不是所有的函式加上都能被當作字面值常量，如果傳入的引數并不是字面值常量而是只是代表只讀，那么還是會被當做普通函式處理，此時constexpr只是推薦編譯器優化，但是并不一定會優化,比如下面這個，還是運行時編譯的，

using namespace std;
constexpr int f(const int x)
{
    return x+10;
}
int main()
{
    int i=cin.get();
    cout<<f(i)<<endl;
}

const在普通函式上一個作用是在回傳值是const的時候表示只讀，因此如果有比如類似賦值之類的操作是無意義的，可以避免bug的出現，即使回傳的是值，也是一個副本而不是值，這類回傳會被編譯器報錯，比如這樣：

class num 
{
public:
    int num = 0;
    int get() 
    {
        return this->num;
    }
};
int main()
{
    num n1;
    n1.num = 1;
    n1.get() = 2;
    system("pause");
}

如果類內部對一個函式的回傳值做const多載，會有不同的效果：

using namespace std;
class nums 
{
public:
    int num = 0;
    nums(int number) :num(number) {};
    int get() 
    {
        cout << "not const" << endl;
        return this->num;
    }
    const int get() const
    {
        cout << "const" << endl;
        return this->num;
    }
};
int main()
{
    nums n1(1);
    const nums n2(2);
    n1.get();
    n2.get();
    system("pause");
}

輸出結果如下，因此我們可以根據是否是const制定不同的函式，

如果我們不寫const版本，有const版本的編譯無法通過

如果倆內容一樣，那么呢簡單的解決方法是這樣，反之并不推薦

using namespace std;
class nums 
{
public:
    int num = 0;
    nums(int number) :num(number) {};
    int get() 
    {
        auto&& temp = static_cast<const nums>(*this).get();
        return const_cast<int&>(temp);
    }
    const int get() const
    {
        cout << "const" << endl;
        return this->num;
    }
};
int main()
{
    nums n1(1);
    const nums n2(2);
    n1.get();
    n2.get();
    system("pause");
}

還有值得指出的是如果希望針對一個const成員函式希望改變部分成員物件，定義的時候可以加上mutable消除掉對這個變數的束縛，比如這樣，

using namespace std;
class nums 
{
public:
    int num = 0;
    mutable int num2 = 0;
    nums(int number) :num(number) {};
    int get() 
    {
        auto&& temp = static_cast<const nums>(*this).get();
        return const_cast<int&>(temp);
    }
    const int get() const
    {
        cout << "const" << endl;
        num2 += 1;
        return this->num;
    }
};
int main()
{
    nums n1(1);
    const nums n2(2);
    n1.get();
    n2.get();
    system("pause");
}

不同檔案的static引數初始化順序

首先先說明這個順序是無解的，比如我們在檔案a里面定義了一個classA，然后檔案b里面定義了另一個classB，我們的類B需要類A的一個static引數來初始化，這種引數叫做no_local static param,而編譯器本身沒辦法保證這個東西是初始化在我們定義類之前的，因此我們需要用一個額函式做一層封裝：

A& getA()
{
    static A a;
    return a;
}

如果涉及多執行緒，我們需要考慮重排問題，就需要加fence防止匯編重排，從而生成多個物件，有點像設計模式種的單例模式了，具體解決方案可以看我設計模式部分的博客，