如何使用C++缺省參數

這篇文章將為大家詳細講解有關如何使用C++缺省參數，文章內容質量較高，因此小編分享給大家做個參考，希望大家閱讀完這篇文章后對相關知識有一定的了解。

一、缺省參數概念

缺省參數是聲明或定義函數時為函數的參數指定一個默認值。在調用該函數時，如果沒有指定實參則采用該默認值，否則使用指定的實參

#include<iostream>
using namespace std;
void TestFunc(int a = 0)//參數缺省值
{
    cout << a << endl;
}
int main()
{
    TestFunc();//沒有指定實參，使用缺省值
    TestFunc(10);//指定實參，使用實參
    return 0;
}

? 有什么用 ?

比如在 C 語言中有個很苦惱的問題是寫棧時，不知道要開多大的空間，之前我們是如果棧為空就先開 4 塊空間，之后再以 2 倍走，如果我們明確知道要很大的空間，那么這樣就只能一點一點的接近這塊空間，就太 low 了。但如果我們使用缺省，明確知道不需要太大時就使用默認的空間大小，明確知道要很大時再傳參

#include<iostream>
using namespace std;
namespace WD
{
    struct Stack
    {
        int* a;
        int size;
        int capacity;    
    };
}
using namespace WD;
void StackInit(struct Stack* ps)
{
    ps->a = NULL; 
    ps->capacity = 0;
    ps->size = 0;
}
void StackPush(struct Stack* ps, int x)
{
    if(ps->size == ps->capacity)
    {
        //ps->capacity *= 2;//err
        ps->capacity == 0 ? 4 : ps->capacity * 2;//這里就必須寫一個三目
    }
}

void StackInitCpp1(struct Stack* ps, int defaultCP)
{
    ps->a = (int*)malloc(sizeof(int) * defaultCP);
    ps->capacity = 0;
    ps->size = defaultCP;
}
void StackInitCpp2(struct Stack* ps, int defaultCP = 4)//ok
{
    ps->a = (int*)malloc(sizeof(int) * defaultCP);
    ps->capacity = 0;
    ps->size = defaultCP;
}
int main()
{
    //假設明確知道這里至少需要100個數據到st1
    struct Stack st1; 
    StackInitCpp1(&st1, 100);
    //假設不知道st2里需要多少個數據 ———— 希望開小點
    struct Stack st2;  
    StackInitCpp2(&st1);//缺省
    return 0;
}

二、缺省參數分類

? 全缺省參數 ?

void TestFunc(int a = 10, int b = 20, int c = 30)
{
    cout << "a = " << a << endl;
    cout << "b = " << b << endl;
    cout << "c = " << c << endl;
    cout << endl;
}
int main()
{
    //非常靈活，
    TestFunc();
    TestFunc(1);
    TestFunc(1, 2);
    TestFunc(1, 2, 3);    
    //TestFunc(1, , 3);//err，注意它沒辦法實現b不傳，只傳a和b，也就是說編譯器只能按照順序傳
    return 0;
}

? 注意：

1?? 全缺省參數只支持順序傳參

? 半缺省參數 ?

//void TestFunc(int a, int b = 10, /*int f, - err*/ int c = 20);//err，

void TestFunc(int a, int b = 10, /*int f, int x = y, -> err*/ int c = 20)
{
    cout << "a = " << a << endl;
    cout << "b = " << b << endl;
    cout << "c = " << c << endl;
    cout << endl;
}
int main()
{
    //TestFunc();//err，至少得傳一個，這是根據形參有幾個非半缺省參數確定的
    TestFunc(1);
    TestFunc(1, 2);
    TestFunc(1, 2, 3);    
    return 0;
}

//a.h
void TestFunc(int a = 10);
//a.cpp
void TestFunc(int a = 20)
{}

? 注意：

  1?? 半缺省參數必須從右往左依次來給出，且不能間隔著給

  2?? 缺省參數不能在函數聲明和定義中同時出現

  3?? 缺省值必須是常量或者全局變量

  4?? C 語言不支持缺省

缺省參數的誤區

使用缺省參數時應該注意避開下列幾種誤區。

1.濫用缺省參數，損害代碼的結構和可讀性。

    void f(bool b=false)
      {
            if (b)
            {
                  file://code of open file
            }
            else
            {
                  file://code of close file
            }
      }

 打開文件和關閉文件在實現代碼上沒有什么共同點，把兩個屬于同一類別的函數誤認為是實現機制相同，憑空捏造一個參數硬把它們湊在一塊，沒有什么好處！相反，誰能記得住f(true)代表打開，f()代表關閉呢？況且，f(false)、f()都可以關閉文件，如果調用者混合使用它們就會增加維護上的困難。這種情況下，寫成兩個獨立的函數，非常清晰。

      void Open()
      {
                  file://code of open file
      }
      void Close()
      {
                  file://code of close file
      }

推而廣之，如下的做法也值得商榷。

      class CString
      {
      private:
            char * pcData;
      public:
            CString(char * pc=NULL);
      };
      CString::CString(char * pc)
      {
            if (pc==NULL)
            {
                  pcData=new char[1];
                  //...
            }
            else
            {
                  pcData=new char[strlen(pc)+1];
                  //...
            }
      }

這一個更具備迷惑性，“都是構造器嘛，當然寫在一塊嘍。”有人說。非也！應當看到，無參構造器與帶char *參數的構造器使用的代碼完全分離，并且缺省參數值NULL在設置數據成員時沒有任何作用。CString()構造器應改寫如下：

      class CString
      {
      private:
            char * pcData;
      public:
            CString();
            CString(char * pc);
      };
      CString::CString()
      {
            pcData=new char[1];
            //...
      }
      CString::CString(char * pc)
      {
            pcData=new char[strlen(pc)+1];
            //...
      }

    總結：
    (1)凡是出現利用缺省參數值作if判斷，并且判斷后實現代碼完全不同的，都應該分拆成兩個獨立的函數。
    (2)只有缺省參數值在函數體中被無歧視的對待，也就是函數對于任何參數的實現機制都相同時，才可能是合理的。

2.多個缺省參數，可能引入邏輯含混的調用方式

設計一個類，不僅僅是提供給客戶代碼正確的功能，更重要的是，對不正確的使用方式作力所能及的限制。

      class CPoint
      {
      public:
            int x;
            int y;
            CPoint(int x=0,int y=0)
            {
                  this->x=x;
                  this->y=y;
            }
      };

乍一看，沒什么問題。構造CPoint對象時如果不指定x、y的初值，則設為原點坐標。讓我們測試一下：

      CPoint pnt1;
      CPoint pnt2(100,100);
      CPoint pnt3(100);      file://[1]

結果發現pnt3的值為(100,0)，跑到x軸上去了。對于想綁定兩個參數，讓它們同時缺省，或者同時不缺省，我們無能為力。但是如果去掉缺省參數，情況就會好轉。

      class CPoint
      {
      public:
            int x;
            int y;
            CPoint()
            {
                  x=0;
                  y=0;
            }
            CPoint(int x,int y)
            {
                  this->x=x;
                  this->y=y;
            }
      };

這樣，語句[1]就會引發編譯錯誤，提醒使用者。

抬杠的會說：“CPoint pnt3(100);初始化到x軸，本來就是我想要的。”真的嗎？那么，請你在你的類文檔中明確指出這種獨特的調用方法，并且告訴使用者，將點初始化到y軸是CPoint pnt4(0,100);這種不對稱的形式。

至于我嘛，self document好了。

3.重載時可能出現二義性

這個簡單，隨便舉個例子：

      void f(int a,int b=0)
      {
      }
      void f(int a)
      {
      }

雖然潛在的模棱兩可的狀態不是一種錯誤，然而一旦使出現f(100);這樣的代碼，潛伏期可就結束了。

4.函數調用中的精神分裂癥

Effective C++ 2nd中的條款，為了本篇的完整性加在這里。這種罕見的癥狀出現的條件是：派生類改寫了基類虛函數的缺省參數值。

      class CBase
      {
      public:
            virtual void f(int i=0)
            {
                  cout<<"in CBase "<<i<<endl;
            }
      };
      class CDerive : public CBase
      {
      public:
            virtual void f(int i=100)
            {
                  cout<<"in CDerive "<<i<<endl;
            }
      };
      CDerive d;
      CBase * pb=&d;
      pb->f();      file://[2]

運行后輸出：
 in CDerive 0

記住，缺省參數是靜態綁定，而虛函數是動態綁定，所以[2]運行的是CDerive::f()的函數體，而使用的缺省值是CBase的0。

關于如何使用C++缺省參數就分享到這里了，希望以上內容可以對大家有一定的幫助，可以學到更多知識。如果覺得文章不錯，可以把它分享出去讓更多的人看到。