開發成長之路（6）-- C++從入門到開發（C++入門不難）

這個圖有點偏差啊，C++是要排在QT之前的，回頭我會對這個圖進行一波的微調，

這已經是進入了第二個階段了，此前如果C語言基礎還沒有打好的小伙伴可以再補一下C語言：
開發成長之路（1）-- C語言從入門到開發（入門篇一）
開發成長之路（2）-- C語言從入門到開發（函式與定制輸入輸出控制函式）
開發成長之路（3）-- C語言從入門到開發（講明白指標和參考，鏈表很難嗎？）
開發成長之路（4）-- C語言從入門到開發（距離開發，還差這一篇）
開發成長之路（5）-- C語言從入門到開發（仿ATM機專案，我寫的第一個專案）

C++背景介紹：C++入門真的不難

C++和C經常被放在一起寫，這難道還需要我再解釋什么嗎？
C/C++，

C++，在C語言的基礎上增添了新的特性，主要為類，
其實類也是源自于對C語言結構體的發揚光大，正因為有了類的出現，C++帶有著強的封裝性、繼承性、多型性，
而后其它的一切，都是由于這些特性而做的二次開發，從而在發展的道路上一騎絕塵，

大家覺得C++難，也就是難在這些后繼發展的內容上吧，
這個階段，讓我們忘掉那些，探求最簡單的C++基本語法！！！

C++語言與C語言的異同

1、編碼規范
在C++中參考的頭檔案和C中的頭檔案不太一樣，但是這并不妨礙二者互用，兼容的，
C里面的輸入輸出頭為：

include<iostream>

using namespace std;	//這一行意為使用名空間std，std里面包含了很多東西

2、標準輸入與輸出
在C++里面，輸入輸出沒那么的麻煩，

cin>>輸入內容>>代碼>>繼續輸入;
cout<<輸出內容<<代碼<<繼續輸出;

3、字串，
C++中有專門的字串類，

#include <string>
using namespace std;

支持的方法有：

4、類，后面細講

類

整張圖來看的明白（源自菜鳥編程）：

其他的不必講了吧，講一下那個變數和方法、訪問修飾符，

類方法

變數，稱為類的屬性，函式，稱為類的方法，

我們來一個實際的例子看一下：

class Box
{
   public:
      double length;      // 長度
      double breadth;     // 寬度
      double height;      // 高度
   
      double getVolume(void)
      {
         return length * breadth * height;
      }
};

也可以在類的外部使用范圍決議運算子 :: 定義該函式

double Box::getVolume(void)
{
    return length * breadth * height;
}

值得注意的是，在分檔案寫代碼的時候，需要將類及類方法宣告在.h檔案中，而類方法的實作放在.cpp檔案中，這時候就需要下面的寫法了，

初始化類物件，并呼叫成員函式的方法：

Box myBox;          // 創建一個物件
 
myBox.getVolume();  // 呼叫該物件的成員函式

或：

Box *myBox = new Box();          // 創建一個物件
 
myBox0->getVolume();  // 呼叫該物件的成員函式

C++ 類訪問修飾符

類成員的訪問限制是通過在類主體內部對各個區域標記 public、private、protected 來指定的，

為什么說C++有很強的封裝性呢，就是因為這三個類訪問修飾符，
且看下去：

class Base {
   public:
  // 公有成員，可以在類外被隨意訪問
 
   protected:
  // 受保護成員，受保護繼承的子類可以使用，自己和友元也可以使用
 
   private:
  // 私有成員，只能在本類內使用，友元函式也行
 
};

我們一般將某些必須開放的介面設定為公有，有些看情況設定為保護，其余一律設為私有，
類的屬性不建議公有！！！

示例：

class Box
{
   public:
      void setWidth( double wid );
      double getWidth( void );
 
   private:
   	  double length;
      double width;
};
 
// 成員函式定義
double Box::getWidth(void)
{
    return width ;	
}
 
void Box::setWidth( double wid )
{
    width = wid;
}

類繼承

有public, protected, private三種繼承方式，它們相應地改變了基類成員的訪問屬性，

可以看出，private 成員只能被本類成員（類內）和友元訪問，不能被派生類訪問；protected 成員可以被派生類訪問，

示例：

class A{
public:
  int a;
  A(){
    a1 = 1;
    a2 = 2;
    a3 = 3;
  }
  void fun(){
    cout << a1 << endl;   //正確
    cout << a2 << endl;   //正確
    cout << a3 << endl;   //正確
  }
public:
  int a1;
protected:
  int a2;
private:
  int a3;
};

class B : public A{
public:
  int a;
  B(int i){
    A();
    a = i;
  }
  void fun(){
    cout << a << endl;       //正確，public成員
    cout << a1 << endl;       //正確，基類的public成員，在派生類中仍是public成員，
    cout << a2 << endl;       //正確，基類的protected成員，在派生類中仍是protected可以被派生類訪問，
    cout << a3 << endl;       //錯誤，基類的private成員不能被派生類訪問，
  }
};

構造/解構式

在初始化類的物件的時候會需要用到類的建構式，建構式的名稱與類的名稱是完全相同的，并且不會回傳任何型別、

建構式可用于為某些成員變數設定初始值，

來看個例子：

class Line
{
   public:
      Line();  // 這是建構式
};
 
// 成員函式定義，包括建構式
Line::Line(void)
{
    cout << "Object is being created" << endl;
}

默認的建構式沒有任何引數，但如果需要，建構式也可以帶有引數，

像這樣：

class Line
{
   public:
      Line(double len);  // 這是建構式
 
   private:
      double length;
};
 
// 成員函式定義，包括建構式
Line::Line( double len)
{
    cout << "Object is being created, length = " << len << endl;
    length = len;
}

還可以這樣：

Line::Line( double len): length(len)
{
    cout << "Object is being created, length = " << len << endl;
}

看個人喜好了，

解構式呢，相對比較簡單，但是也是有坑在里面的，

類的解構式是類的一種特殊的成員函式，它會在每次洗掉所創建的物件時執行，
一般用于程式員手動回收記憶體，

class Line
{
   public:
      Line();   // 這是建構式宣告
      ~Line();  // 這是解構式宣告
};
 
// 成員函式定義，包括建構式
Line::Line(void)
{
    cout << "Object is being created" << endl;
}
Line::~Line(void)
{
    cout << "Object is being deleted" << endl;
}

拷貝建構式

拷貝建構式是一種特殊的建構式，它在創建物件時，是使用同一類中之前創建的物件來初始化新創建的物件，

class Line
{
   public:
      Line( int len );             // 簡單的建構式
      Line( const Line &obj);      // 拷貝建構式
      ~Line();                     // 解構式
 
   private:
      int *ptr;
};
 
// 成員函式定義，包括建構式
Line::Line(int len)
{
    cout << "呼叫建構式" << endl;
    // 為指標分配記憶體
    ptr = new int;
    *ptr = len;
}
 
Line::Line(const Line &obj)
{
    cout << "呼叫拷貝建構式并為指標 ptr 分配記憶體" << endl;
    ptr = new int;
    *ptr = *obj.ptr; // 拷貝值
}

this指標

this指標存在于類中，指代的是這個類本身的意思，
其實我也想不出來太多它必須存在的場景，碧如說：引數名和類屬性名一樣的時候，或者函式指標引數名和類方法名一樣的時候吧，

反正看到this的時候不要大驚小怪就好啦，

關于類，大致講到這里，

C++ 動態記憶體

了解一下堆疊：

    堆疊：在函式內部宣告的所有變數都將占用堆疊記憶體，
    堆：這是程式中未使用的記憶體，在程式運行時可用于動態分配記憶體，

使用 new 運算子來為任意的資料型別動態分配記憶體的通用語法：

new data-type;

使用 delete 運算子釋放它所占用的記憶體：

delete pvalue;        // 釋放 pvalue 所指向的記憶體

示例：

double* pvalue  = NULL; // 初始化為 null 的指標
pvalue  = new double;   // 為變數請求記憶體

balabala

delete pvalue;        // 釋放 pvalue 所指向的記憶體

陣列的動態記憶體分配

直接上手吧：

char* pvalue  = NULL;   // 初始化為 null 的指標
pvalue  = new char[20]; // 為變數請求記憶體

delete [] pvalue;        // 洗掉 pvalue 所指向的陣列

物件的動態記憶體分配

int main( )
{
   Box* myBoxArray = new Box();
 
   delete myBoxArray;
   return 0;
}

先到這里啦，我還有點事情，