C++語言（01）——C到C++的升級

1、C++簡介

1.1、各種語言的特性

• c語言：效率高，保留了較多的低級特性(直接操作內(nèi)存)，面向過程
• C++: 是C語言的是增強(qiáng)版，兼容C語言的所有特性，面向?qū)ο?，依然保留了部分低級語言的特性
• java: 是C++語言的剪裁版，完全的面向?qū)ο?，需要虛擬機(jī)運(yùn)行，所依效率較低
• C#： 是java語言的競爭者，由微軟開發(fā)，特性基本與java基本相同
• D： java和C#的升級，優(yōu)化了java和C#的運(yùn)行效率
  
  現(xiàn)代軟件產(chǎn)品框架圖：
  

  1.2、C++語言的內(nèi)容

  C++語言是在C語言基礎(chǔ)上擴(kuò)展發(fā)展而來，完全兼容C語言。在C語言基礎(chǔ)上，C++語言主要包括三大部分：C++對C語言基礎(chǔ)語法的擴(kuò)展，面向?qū)ο?繼承，封裝，多態(tài)、異常處理)，STL等。

  2、C語言到C++的升級

  共有一下11點(diǎn)，我們一一學(xué)習(xí)解析：
  1.類型增強(qiáng)
  2.輸入與輸出
  3.函數(shù)重載
  4.操作符重載
  5.默認(rèn)參數(shù)
  6.引用
  7.new/delete
  8.內(nèi)聯(lián)函數(shù)
  9.類型強(qiáng)轉(zhuǎn)
  10.命名空間
  11.系統(tǒng)string類

  2.1類型增強(qiáng)

  1.變量可以在使用時(shí)再定義

  c++更強(qiáng)調(diào)語言的實(shí)用性，所有的變量可以在使用時(shí)再定義，C語言中需要定義在作用域開始的地方。

  2.bool類型

  (1)C語言中是沒有bool類型的，要使用int類型來代替。
  (2)C++中有專用的bool類型，占用1個(gè)字節(jié)的空間，true表示真，編譯器內(nèi)部用1來表示，false表示假，用0表示
  (3)true和false是C++中的關(guān)鍵字。
  (4)C++編譯器會將非0值轉(zhuǎn)換為true，將0值轉(zhuǎn)換為false。
  (5)bool類型是C++語言中的基本數(shù)據(jù)類型，可以定義bool類型的全局變量、常量、指針、數(shù)組。

  3.三目運(yùn)算符

  (1)c語言中也有三目運(yùn)算符，返回的是變量的值，不能做左值
  (2)C++中的三目運(yùn)算符可以返回變量本身，既可以做右值，也可以做左值(返回值必須都是變量)，如果三目運(yùn)算符的返回值中有常量，則不能做左值。

#include <stdio.h>
int main(void)
{
    int a = 1,b = 2;
    (a < b ? a : b) = 3;        //正確，返回a或b的引用，可以做左值
    //(a < b ? 1 : b) = 1;      //錯誤，返回1或b的引用，不可以做左值
    //C++中的三目運(yùn)算符可以返回變量本身，既可以做右值，也可以做左值(返回值必須都是變量)，如果三目運(yùn)算符的返回值中有常量，則不能做左值

    printf("a = %d, b = %d.\n", a, b);
}

4.枚舉

C語言中枚舉本質(zhì)就是整型，枚舉變量可以用任意整型賦值。而c++中枚舉變量，只能用被枚舉出來的元素初始化。
在C語言中，枚舉的使用:

#include <stdio.h>
enum weekday
{

    monday,
    tuesday,
    wednesday,
    thursday,
    friday,
    saturday,
    sunday
};
int main(int argc, char **argv)
{
    enum weekday day = monday;
    enum weekday a = sunday;
    enum weekday b = 100;

    //weekday c = sunday;錯誤用法，需要使用enum聲明
    printf("%d %d %d\n", day, a, b);

    return 0;
}

在C++語言中枚舉的使用：

#include <iostream>
using namespace std;
enum weekday
{
    monday,tuesday,wednesday,thursday,friday,saturday,sunday
};
int main()
{
    weekday day = sunday;       // 不需要使用enum聲明
    enum weekday a = monday;
    // weekday b = 100;     類型不兼容

    cout<<day<<" "<<a<<endl;

    return 0;
}

2. 2.輸入與輸出

1、cin&cout

cin和cout是C++的標(biāo)準(zhǔn)輸入流和輸出流，在頭文件 iostream 中定義。
流名 含義 隱含設(shè)備 流名 含義 隱含設(shè)備
cin 標(biāo)準(zhǔn)輸入 鍵盤 cerr 標(biāo)準(zhǔn)錯誤輸出 屏幕
cout 標(biāo)準(zhǔn)輸出 屏幕 clog cerr 的緩沖輸出 屏幕

#include <iostream>
using namespace std;
int main()
{
    char name[30];
    int age;

    cout<<"pls input name and age:"<<endl;

    cin>>name;
    cin>>age;

    cout<<"your name is: "<<name<<endl;
    cout<<"your age is: "<<age<<endl;

    return 0;
}

2、格式化

A、按進(jìn)制輸出數(shù)據(jù)類型
B、設(shè)置域?qū)?，設(shè)置左右對齊及填充字符
C、實(shí)型數(shù)據(jù)的設(shè)置

#include <iostream>     // std::cout, std::endl
#include <iomanip>      // std::setw
using namespace std;
int main()
{
    int i = 16;

    // 按進(jìn)制輸出數(shù)據(jù)類型
    cout<<dec<<i<<endl;
    cout<<hex<<i<<endl;
    cout<<oct<<i<<endl;

    cout << endl;
    cout << endl;

    // 設(shè)置域?qū)?，設(shè)置左右對齊及填充字符
    cout<<setw(10)<<1234<<endl;
    cout<<setw(10)<<setfill('0')<<1234<<endl;
    cout<<setw(10)<<setfill('0')<<setiosflags(ios::left)<<1234<<endl;
    cout<<setw(10)<<setfill('-')<<setiosflags(ios::right)<<1234<<endl;

    cout << endl;
    cout << endl;

    // 實(shí)型數(shù)據(jù)的設(shè)置
    cout<<setw(5)<<'a'<<endl<<setw(5)<<100<<endl
    <<setprecision(2)<<setiosflags(ios::fixed)<<120.00<<endl;

    return 0;
}

2.3函數(shù)重載

本節(jié)只做簡單介紹后續(xù)章節(jié)會再重點(diǎn)介紹

2.3.1、重載規(guī)則

A、函數(shù)名相同。
B、參數(shù)個(gè)數(shù)不同，參數(shù)的類型不同，參數(shù)順序不同，均可構(gòu)成重載。
C、返回值類型不同則不可以構(gòu)成重載。

2.3.2、函數(shù)重載的匹配規(guī)則

A、嚴(yán)格匹配，找到則調(diào)用。
B、通過隱式轉(zhuǎn)換尋求一個(gè)匹配，找到則調(diào)用。
C++允許int到long和double的隱式類型轉(zhuǎn)換，因此遇到這種情型，則會引起二義性，解決方法是在調(diào)用時(shí)強(qiáng)轉(zhuǎn)類型。

#include <stdio.h>
#include <string.h>
/*
int func(int x)
{
    return x;
}
*/
double func(int x)  //編譯報(bào)錯，前兩個(gè)函數(shù)有歧義，可見返回值函數(shù)的返回值不能做為函數(shù)重載的依據(jù)
{                   //重載的條件：函數(shù)名相同，參數(shù)的（大小、類型、個(gè)數(shù)）至少有一個(gè)不同
    return x;
}

int func(int a, int b)
{
    return a + b;
}

int func(const char* s)
{
    return strlen(s);
}

int main(int argc, char *argv[])
{
    printf("%d\n", func(3));
    printf("%d\n", func(4, 5));
    printf("%d\n", func("D.T.Software"));

    return 0;
}

2.3.3、函數(shù)重載的底層實(shí)現(xiàn)

C++利用 name mangling(傾軋)技術(shù)，來改名函數(shù)名，區(qū)分參數(shù)不同的同名函數(shù)。
實(shí)現(xiàn)原理：用 vci f l d表示void char int float long double及其引用。
void func(char a); // func_c(char a)
void func(char a, int b, double c);//func_cid(char a, int b, double c);
name mangling發(fā)生在兩個(gè)階段，.cpp編譯階段，和.h的聲明階段。只有兩個(gè)階段同時(shí)進(jìn)行，才能匹配調(diào)用。
C++完全兼容C語言，因此必須完全兼容C的類庫。由于.c文件的類庫文件中函數(shù)名并沒有發(fā)生name manling行為，而在包含.c文件所對應(yīng)的.h文件時(shí)，.h 文件要發(fā)生name manling行為，因而會在編譯鏈接時(shí)候發(fā)生錯誤。
C++為了避免上述錯誤的發(fā)生，重載了關(guān)鍵字extern。只需要要避免name manling的函數(shù)前，加extern "C"如有多個(gè)，則extern "C"{}。
C語言標(biāo)準(zhǔn)庫中實(shí)際上對C++語言程序引用時(shí)做了特殊處理，在C++語言編譯器編譯時(shí)使用extern "C"將C語言的標(biāo)準(zhǔn)庫函數(shù)排除了命名傾軋。

#ifdef __cplusplus
extern “C”{
#endif
標(biāo)準(zhǔn)庫函數(shù)
#ifdef __cplusplus
}
#endif

2.4操作符重載：

操作符的重載以函數(shù)的方式進(jìn)行，本質(zhì)是用特殊形式的函數(shù)擴(kuò)展操作符的功能
操作符的重載不能改變操作符的原生語義

#include <stdio.h>

class Complex 
{
    int a;
    int b;
public:
    Complex(int a = 0, int b = 0)
    {
        this->a = a;
        this->b = b;
    }

    int getA()
    {
        return a;
    }

    int getB()
    {
        return b;
    }

    friend Complex Add(const Complex& p1, const Complex& p2);
};

Complex Add(const Complex& p1, const Complex& p2)

{
    Complex ret;

    ret.a = p1.a + p2.a;
    ret.b = p1.b + p2.b;

    return ret;
}

int main()
{

    Complex c1(1, 2);
    Complex c2(3, 4);
    Complex c3 = Add(c1, c2); // c1 + c2

    printf("c3.a = %d, c3.b = %d\n", c3.getA(), c3.getB());

    return 0;
}

注意：邏輯運(yùn)算符和逗號表達(dá)式重載后不能保持原生語義，原因在于函數(shù)參數(shù)計(jì)算時(shí)順序是不確定的。

#include <iostream>
#include <string>

/**
實(shí)際工程中避免重載邏輯操作符，通過重載比較操作符代替邏輯操作符重載或使用成員函數(shù)代替邏輯操作符重載
    如果非要重載，使用全局函數(shù)進(jìn)行
**/

using namespace std;

class Test
{
    int mValue;
public:
    Test(int v)
    {
        mValue = v;
    }
    int value() const
    {
        return mValue;
    }
};
//如果非要重載，使用全局函數(shù)進(jìn)行
bool operator && (const Test& l, const Test& r)     //const對象只能調(diào)用const成員函數(shù)
{
    return l.value() && r.value();
}

bool operator || (const Test& l, const Test& r)
{
    return l.value() || r.value();
}

Test func(Test i)
{
    cout << "Test func(Test i) : i.value() = " << i.value() << endl;

    return i;
}

int main()
{
    Test t0(0);
    Test t1(1);

    //C++通過函數(shù)調(diào)用擴(kuò)展操作符的功能，進(jìn)入函數(shù)體前必須完成所有參數(shù)的計(jì)算，但參數(shù)的計(jì)算次序是不定的(短路法則失效)
    if( func(t0) && func(t1) )  // operator &&(func(0), func(1))
    {
        cout << "Result is true!" << endl;
    }
    else
    {
        cout << "Result is false!" << endl;
    }

    cout << endl;

    if( func(1) || func(0) )
    {
        cout << "Result is true!" << endl;
    }
    else
    {
        cout << "Result is false!" << endl;
    }

    return 0;
}

2.5默認(rèn)參數(shù)&占位參數(shù)：

C++中引入了默認(rèn)參數(shù)的概念，可以從左向右依次提供默認(rèn)參數(shù)

#include <stdio.h>

int add(int x, int y = 0, int z = 0);   //設(shè)計(jì)函數(shù)時(shí)，參數(shù)的默認(rèn)值必須從右向左提供

int main(int argc, char *argv[])
{
    printf("%d\n", add(1));
    printf("%d\n", add(1, 2));
    printf("%d\n", add(1, 2, 3));

    return 0;
}

int add(int x, int y, int z)
{
    return x + y + z;
}

一個(gè)函數(shù)，不能既作重載，又作默認(rèn)參數(shù)的函數(shù)。當(dāng)你少寫一個(gè)參數(shù)時(shí)，系統(tǒng)無法確認(rèn)是重載還是默認(rèn)參數(shù)。
占位參數(shù)只有函數(shù)的參數(shù)類型聲明，而沒有參數(shù)名聲明，為了兼容C語言的不規(guī)范寫法

#include <stdio.h>

int func(int x, int);
// int func(int x, int = 0);    //解決方法是結(jié)合默認(rèn)參數(shù)和占位參數(shù)

int main(int argc, char *argv[])
{
    printf("%d\n", func(1));    //這樣可以使用不同的方法調(diào)用
    printf("%d\n", func(2, 3));

    return 0;
}

int func(int x, int)
{
    return x;
}

2.6引用：

引用是一個(gè)變量的別名，本質(zhì)是一個(gè)指針常量。

int a,b;
int &r = a;
int &r = b; //錯誤，不可更改原有的引用關(guān)系
r = b;//正確，賦值
float &rr = b; //錯誤，引用類型不匹配
cout<<&a<<&r<<endl; //變量與引用具有相同的地址。
int &ra = r; //可對引用更次引用，表示 a 變量有兩個(gè)別名，分別是 r 和 ra

//引用的應(yīng)用
void swap(int &a, int &b)
{
    int tmp;
    tmp = a;
    a = b;
    b = tmp;
}
void swap(char * &a, char * &b)
{
        char *t = a;
    a = b;
    b = t;
}

//引用的提高
//A、可以定義指針的引用，但不能定義引用的引用。
int a;
int* p = &a;
int*& rp = p; // ok
int& r = a;
int&& rr = r; // error

//B、可以定義指針的指針(二級指針)，但不能定義引用的指針。
int a;
int* p = &a;
int** pp = &p; // ok
int& r = a;
int&* pr = &r; // error
//C、可以定義指針數(shù)組，但不能定義引用數(shù)組，可以定義數(shù)組引用。
int a, b, c;
int* parr[] = {&a, &b, &c}; // ok
int& rarr[] = {a, b, c}; // error
int arr[] = {1, 2, 3};
int (&rarr)[3] = arr; // ok 的

//E、常引用
const對象的引用必須是const的，將普通引用綁定到const對象是不合法的。const引用可使用相關(guān)類型的對象(常量,非同類型的變量或表達(dá)式)初始化，是const引用與普通引用最大的區(qū)別。 const int &a=2;是合法的。 double x=3.14; constint &b=a;也是合法的。
非const引用只能綁定到與該引用同類型的對象。
總結(jié)：
A、引用沒有定義，是一種關(guān)系型聲明。聲明它和原有某一變量(實(shí)體)的關(guān)系。故 而類型與原類型保持一致，且不分配內(nèi)存。與被引用的變量有相同的地址。
B、聲明的時(shí)候必須初始化，一經(jīng)聲明，不可變更。
C、可對引用再次引用。多次引用的結(jié)果，是某一變量具有多個(gè)別名。
D、&符號前有數(shù)據(jù)類型時(shí)，是引用。其它皆為取地址。
E、不可定義引用的指針，不可定義引用數(shù)組（數(shù)組內(nèi)部數(shù)據(jù)元素類型必須相同）

2.7new/delete：

C++中引入了新的內(nèi)存分配機(jī)制
(1)C語言中通過malloc和free來申請和釋放內(nèi)存空間
(2)C++中使用new和delete來來申請和釋放內(nèi)存空間
(3)new和malloc的區(qū)別
1、new是C++中的關(guān)鍵字而malloc是C語言中的一個(gè)庫函數(shù)
2、new以具體的類型為單位進(jìn)行內(nèi)存的分配，而malloc是以字節(jié)為單位進(jìn)行內(nèi)存分配
3、new在申請單個(gè)類型變量時(shí)可以進(jìn)行初始化，而malloc不具有初始化的特新
(4)new的使用

//1、//申請type類型的空間
type *pointer = new type    
delete pointer
//2、//為type類型的數(shù)組申請空間，數(shù)組中有N個(gè)元素
type *pointer = new type[N] 
delete[] pointer    //此處的[]不能丟
//3、//申請type類型的空間,并賦值為1
type *pointer = new type(1) 
delete pointer

使用實(shí)例：

#include <stdio.h>

int main()
{
    int* p = new int;   //從字面來理解，為新類型int分配空間

    *p = 5;
    *p = *p + 10;

    printf("p = %p\n", p);
    printf("*p = %d\n", *p);

    delete p;

    p = new int[10];        //堆內(nèi)存申明是一般所給的內(nèi)存會比實(shí)際申請的要多一些
                            //所依此處至少分配了40字節(jié)的空間

    for(int i=0; i<10; i++)
    {
        p[i] = i + 1;

        printf("p[%d] = %d\n", i, p[i]);
    }

    delete[] p;         //此處的[]不可以丟

    return 0;
}

2.8內(nèi)聯(lián)函數(shù)：

2.8.1、函數(shù)與宏的區(qū)別
(1)普通函數(shù)由編譯器處理
優(yōu)勢：編譯器會做靜態(tài)的參數(shù)類型檢查（返回值，參數(shù)）
缺點(diǎn)：在于有調(diào)用開銷（壓棧、跳轉(zhuǎn)、返回）
(2)帶參宏由預(yù)處理器處理
優(yōu)勢：直接字符替換，沒有調(diào)用開銷
缺點(diǎn)：沒有靜態(tài)參數(shù)類型檢查，不如函數(shù)直觀，易出錯
2.8.2內(nèi)聯(lián)函數(shù)
優(yōu)點(diǎn)：避免調(diào)用時(shí)的額外開銷（入棧與出棧操作）
缺點(diǎn)：內(nèi)聯(lián)函數(shù)的函數(shù)體在代碼段中會出現(xiàn)多個(gè)“副本”，因此會增加代碼段的空間。
本質(zhì)：以犧牲代碼段空間為代價(jià)，提高程序的運(yùn)行時(shí)間的效率。
適用場景：函數(shù)體很“小”，且被“頻繁”調(diào)用。
2.8.3內(nèi)聯(lián)函數(shù)
(1)結(jié)合了宏定義和函數(shù)的優(yōu)勢，直接將函數(shù)體插入函數(shù)調(diào)用的地方，沒有調(diào)用開銷，使用inline關(guān)鍵字來申明。
(2)C++編譯器不一定會滿足函數(shù)的內(nèi)聯(lián)請求，類似于register關(guān)鍵字
(3)在擴(kuò)展C++編譯器中提供了強(qiáng)制內(nèi)聯(lián)的關(guān)鍵字，可以實(shí)現(xiàn)內(nèi)聯(lián)，此外還可以通過對編譯器進(jìn)行配置，從而強(qiáng)制內(nèi)聯(lián)。
(4)g++中使用：attribute((always_inline))來強(qiáng)制內(nèi)聯(lián)
vc10.0中使用：__forceinline實(shí)現(xiàn)
(5)老版編譯器（標(biāo)準(zhǔn)c）中不支持強(qiáng)制內(nèi)聯(lián)

2.9類型強(qiáng)轉(zhuǎn)：

1、靜態(tài)類型轉(zhuǎn)換，靜態(tài)類型轉(zhuǎn)換是在編譯期內(nèi)即可決定其類型的轉(zhuǎn)換。
2、動態(tài)類型轉(zhuǎn)換，用于多態(tài)中的父子類之間的強(qiáng)制轉(zhuǎn)化
2、常量類型轉(zhuǎn)換，目標(biāo)類類型只能是指針或引用,const_cast將轉(zhuǎn)換掉表達(dá)式的const屬性
4、重解釋類型轉(zhuǎn)換，為數(shù)據(jù)的二進(jìn)制形式重新解釋，但是不改變其值。

#include <stdio.h>

void static_cast_demo()
{
    int i = 0x12345;
    char c = 'c';
    int* pi = &i;
    char* pc = &c;

    c = static_cast<char>(i);
    //pc = static_cast<char*>(pi);      //error
}

void const_cast_demo()
{
    const int& j = 1;       //定義了一個(gè)只讀變量j
    int& k = const_cast<int&>(j);

    const int x = 2;        ////定義了一個(gè)常量x
    int& y = const_cast<int&>(x);   //當(dāng)&/extern作用于一個(gè)常量時(shí)，c++也會像C語言中一樣為其分配內(nèi)存空間

    //int z = const_cast<int>(x);       //error

    k = 5;

    printf("k = %d\n", k);      // 5
    printf("j = %d\n", j);      // 5

    y = 8;

    printf("x = %d\n", x);      // 2， x是常量，使用時(shí)從字符表取出
    printf("y = %d\n", y);      // 8
    printf("&x = %p\n", &x);    //y是x的引用（別名），共用同一內(nèi)存空間
    printf("&y = %p\n", &y);
                                //&x = 0xbf8872dc
                                //&y = 0xbf8872dc
}

void reinterpret_cast_demo()
{
    int i = 0;
    char c = 'c';
    int* pi = &i;
    char* pc = &c;

    pc = reinterpret_cast<char*>(pi);
    pi = reinterpret_cast<int*>(pc);
    pi = reinterpret_cast<int*>(i);
    //c = reinterpret_cast<char>(i);        // error
}

void dynamic_cast_demo()
{
    int i = 0;
    int* pi = &i;
    //char* pc = dynamic_cast<char*>(pi);   //error  
}

int main()
{
    static_cast_demo();
    const_cast_demo();
    reinterpret_cast_demo();
    dynamic_cast_demo();

    return 0;
}

//C++ 內(nèi)存申請失敗會拋出異常

try{
    int *p = new int[10];
}
catch(const std::bad_alloc e)
{
    return -1;
}
//C++ 內(nèi)存申請失敗不拋出異常版本
int *q = new (std::nothrow)int[10];
if(q == NULL)
    return -1;

正是由于C++的內(nèi)存申請會拋出異常，所以在面對自定義類型對象構(gòu)造時(shí)，一定要確保異常安全。

2.10命名空間：

解決C語言中的全局變量命名沖突的問題，可以嵌套使用

#include <stdio.h>
namespace First     //從全局空間中劃分出一塊命名為First，類似于劃分地域
{
    int i = 0;
}
namespace Second
{
    int i = 1;

    namespace Internal
    {
        struct P    //c++中此處的P即就是一個(gè)結(jié)構(gòu)體類型，等價(jià)于C語言中的struct P
        {
            int x;
            int y;
        };
    }
}
int main()
{
    using namespace First;          //我們要在main函數(shù)中使用First命名空間中的一切
    using Second::Internal::P;      //我們要在main函數(shù)中使用Second命名空間中的Internal空間中的P這個(gè)結(jié)構(gòu)體

    printf("First::i = %d\n", i);
    printf("Second::i = %d\n", Second::i);

    P p = {2, 3};       //C++ 里對struct關(guān)鍵字進(jìn)行加強(qiáng)，可以直接定義結(jié)構(gòu)體 

    printf("p.x = %d\n", p.x);
    printf("p.y = %d\n", p.y);

    return 0;
}

2.11系統(tǒng)string類

本質(zhì)上是C++中的自定義類型，重載了數(shù)組操作符，支持C語言中但字節(jié)訪問的特定。
除了使用字符數(shù)組來處理字符串以外，C++引入了字符串類型。可以定義字符串變量。

2.11.1、定義和初始化

string str;
str = "china";
string str2 = " is great ";
string str3 = str2;

2.11.2、類型大小

cout<<sizeof(string)<<" "<<str.max_size()<<str.size()<<endl;

2.11.3、運(yùn)算

//A、賦值
string str3 = str2;
//B、加法
string combine = str + str2;
//C、關(guān)系
string s1 = "abcdeg";
string s2 = "12345";
if(s1>s2)
cout<<"s1>s2"<<endl;
else
cout<<"s1<s2"<<endl;

2.11.4、string類型數(shù)組

string數(shù)組是高效的，如果用二維數(shù)組來存入字符串?dāng)?shù)組的話，則容易浪費(fèi)空間，此時(shí)列數(shù)是由最長的字符串決定。如果用二級指針申請堆空間，依據(jù)大小申請相應(yīng)的空間，雖然解決了內(nèi)存浪費(fèi)的問題，但是操作麻煩。用 string 數(shù)組存儲，字符串?dāng)?shù)組的話，效率即高又靈活。

string sArray[10] = {
"0",
"1",
"22",
"333",
"4444",
"55555",
"666666",
"7777777",
"88888888",
"999999999",
};
for(int i=0; i<10; i++)
{
cout<<sArray[i]<<endl;
}

2.11.5、string類的成員函數(shù)

int capacity()const;  //返回當(dāng)前容量（即string中不必增加內(nèi)存即可存放的元素個(gè)數(shù)）
int max_size()const;    //返回string對象中可存放的最大字符串的長度
int size()const;        //返回當(dāng)前字符串的大小
int length()const;       //返回當(dāng)前字符串的長度
bool empty()const;        //當(dāng)前字符串是否為空
void resize(int len,char c);//把字符串當(dāng)前大小置為len，并用字符c填充不足的部分

12.C語言開發(fā)人員的建議

1、在 C++中幾乎不需要用宏，用const或enum定義明顯的常量，用inline避免函數(shù)調(diào)用的額外開銷，用模板去刻畫一族函數(shù)或類型，用namespace去避免命名沖突。
2、不要在你需要變量之前去聲明，以保證你能立即對它進(jìn)行初始化。
3、不要用malloc，new運(yùn)算會做的更好
4、避免使用 void*、指針?biāo)阈g(shù)、聯(lián)合和強(qiáng)制，大多數(shù)情況下，強(qiáng)制都是設(shè)計(jì)錯誤的指示器。
5、盡量少用數(shù)組和C風(fēng)格的字符串，標(biāo)準(zhǔn)庫中的string和vector可以簡化程序
6、更加重要的是，試著將程序考慮為一組由類和對象表示的相互作用的概念，而不是一堆數(shù)據(jù)結(jié)構(gòu)和一些可以撥弄的二進(jìn)制。