與 C 語(yǔ)言相比，C++ 語(yǔ)言的優(yōu)點(diǎn)：

1. 從程序運(yùn)行的穩(wěn)定性來(lái)說(shuō)，C++ 語(yǔ)言比 C 語(yǔ)言更安全，它支持過(guò)程化編程、面向?qū)ο缶幊毯头盒途幊?。因?yàn)槟軌蛑С置嫦驅(qū)ο蟮拈_發(fā)方式，所以C++語(yǔ)言的應(yīng)用領(lǐng)域更加廣泛。
2. C++ 語(yǔ)言可運(yùn)行于多種平臺(tái)上，如 Windows、MAC 操作系統(tǒng)及 UNIX 的多種版本。
3. C++ 語(yǔ)言中加入了面向?qū)ο?/span>的概念，雖然 C 語(yǔ)言的語(yǔ)法絕大部分都被保留在 C++ 語(yǔ)言中，但 C++ 的程序結(jié)構(gòu)與 C 語(yǔ)言的程序結(jié)構(gòu)存在很大差別。C++ 語(yǔ)言對(duì) C 語(yǔ)言做了很多改進(jìn)，C++語(yǔ)言相對(duì)于C語(yǔ)言的最根本的變化是引進(jìn)了類和對(duì)象的概念。

（1）基本的輸入/輸出

• 在 C++ 中，可以使用流提取運(yùn)算符 “>>” 從標(biāo)準(zhǔn)輸入設(shè)備鍵盤取得數(shù)據(jù)。例如，語(yǔ)句 “cin>>x;” 從鍵盤獲取輸入數(shù)據(jù)并賦給變量 x 。使用?cin?可以獲得多個(gè)來(lái)自鍵盤的輸入值。

• cout?是一個(gè)標(biāo)準(zhǔn)輸出流對(duì)象，使用流插入運(yùn)算符 “<<” 向輸出設(shè)備屏幕輸出信息。

/* 示例：基本的輸入輸出 */
#include<iostream>
#include<string>
using namespace std;
int main( )
{
  int oneInt1,oneInt2;
  char strArray[20];
  string str;
  double oneDouble;
  char oneChar='a';
  cout<<"輸入兩個(gè)整型值，一個(gè)字符，一個(gè)字符串和一個(gè)浮點(diǎn)值，";
  cout<<"以空格、Tab鍵或〈Enter〉鍵分隔:"<<endl;
  cin>>oneInt1>>oneInt2>>oneChar>>strArray>>oneDouble;
  str=strArray;
  cout<<"輸入的數(shù)據(jù)是:"<<endl;                         // endl 的作用是換行
  cout<<"字符串是：\t\t"<<str<<endl                    // \t 是制表符 Tab
      <<"兩個(gè)整型值分別是：\t"<<oneInt1<<"和\t"<<oneInt2<<endl
      <<"字符是：\t\t"<<oneChar<<"\n"                  // \n 是換行符，與 endl 效果相同
      <<"浮點(diǎn)值是：\t\t"<<oneDouble<<endl;
  return 0;
}


/* 假定，程序運(yùn)行時(shí)輸入：/*
10 20 g abc 25.5

/* 屏幕上會(huì)輸出如下的運(yùn)行結(jié)果：/*
輸入的數(shù)據(jù)是：
字符串是： abc
兩個(gè)整型值分別是： 10 和 20
字符是： g
浮點(diǎn)值是： 25.5

（2）頭文件和命名空間

? iostream? 是 C++ 的 標(biāo)準(zhǔn)輸入/輸出流 。

• 當(dāng)在程序中使用 cin 或 cout 時(shí)，必須在程序的最前面包含這個(gè)流。
• 如果還要使用其他的內(nèi)容，那么需要包含其他的頭文件。
• 每條 #include 指令僅可以包含一個(gè)頭文件，如果需要包含多個(gè)頭文件，則需要使用多條#include 指令。 【嵌入指令】

? 在 C++ 中，頭文件不再以 “.h” 結(jié)尾，以 “.h” 結(jié)尾的頭文件是 C 語(yǔ)言中常用的頭文件。

常用的頭文件有以下一些：

• 標(biāo)準(zhǔn)輸入輸出流：<iostream>
• 標(biāo)準(zhǔn)文件流：<fstream>
• 標(biāo)準(zhǔn)字符串處理函數(shù)：<string>
• 標(biāo)準(zhǔn)數(shù)學(xué)函數(shù)：<cmath>

當(dāng)使用 尖括號(hào) 時(shí)，C++ 編譯器將 首先在 C++ 系統(tǒng)設(shè)定的目錄中尋找要包含的文件 ，如果沒(méi)有找到，再到指令中指定的目錄中去查找。 采用雙引號(hào)時(shí)，C++ 編譯器在用戶當(dāng)前目錄下或指令中指定的目錄下尋找要包含的文件。

• 例如，要包含e:\myprog目錄下的頭文件 ex1.h，相應(yīng)的語(yǔ)句如下：

#include "e:\myprog\ex1.h"

C++ 中為了避免名字定義沖突，特別引入了 “命名空間” 的定義，即? namespace? 。命名空間的作用是為了消除同名引起的歧義。 using namespace std;

定義一個(gè)命名空間的語(yǔ)法格式如下：

namespace 命名空間名

{

? ? ? 命名空間內(nèi)的各種聲明(函數(shù)聲明、類聲明、……）

}

（3）強(qiáng)制類型轉(zhuǎn)換運(yùn)算符?

static_cast 用于將一種數(shù)據(jù)類型轉(zhuǎn)換成另一種數(shù)據(jù)類型，使用格式如下：

【格式】static_cast<類型名>(表達(dá)式）

【功能】 其功能是把表達(dá)式轉(zhuǎn)換為類型名所指定的類型

【注意】 static_cast 也可以省略

【示例】

/* 示例（程序 1-1 ）：基本的輸入輸出 */
#include<iostream>
#include<string>
using namespace std;
int main( )
{
  int oneInt1,oneInt2;
  char strArray[20];
  string str;
  double oneDouble;
  char oneChar='a';
  cout<<"輸入兩個(gè)整型值，一個(gè)字符，一個(gè)字符串和一個(gè)浮點(diǎn)值，";
  cout<<"以空格、Tab鍵或〈Enter〉鍵分隔:"<<endl;
  cin>>oneInt1>>oneInt2>>oneChar>>strArray>>oneDouble;
  str=strArray;
  cout<<"輸入的數(shù)據(jù)是:"<<endl;                         // endl 的作用是換行
  cout<<"字符串是：\t\t"<<str<<endl                    // \t 是制表符 Tab
      <<"兩個(gè)整型值分別是：\t"<<oneInt1<<"和\t"<<oneInt2<<endl
      <<"字符是：\t\t"<<oneChar<<"\n"                  // \n 是換行符，與 endl 效果相同
      <<"浮點(diǎn)值是：\t\t"<<oneDouble<<endl;
  return 0;
}


/* 假定，程序運(yùn)行時(shí)輸入：/*
10 20 g abc 25.5

/* 屏幕上會(huì)輸出如下的運(yùn)行結(jié)果：/*
輸入的數(shù)據(jù)是：
字符串是： abc
兩個(gè)整型值分別是： 10 和 20
字符是： g
浮點(diǎn)值是： 25.5

/* 以程序 1-1 中聲明的變量為例，下面 4 種寫法都是正確的：*/
oneInt2=static_cast<int>(oneDouble);   //強(qiáng)制類型轉(zhuǎn)換
oneInt2=int(oneDouble);                //強(qiáng)制類型轉(zhuǎn)換運(yùn)算符的新形式
oneInt2=(int)oneDouble;                //強(qiáng)制類型轉(zhuǎn)換運(yùn)算符的舊有形式
oneInt2=oneDouble;                     //自動(dòng)類型轉(zhuǎn)換

（4）函數(shù)參數(shù)的默認(rèn)值?

• C++ 語(yǔ)言規(guī)定，提供默認(rèn)值時(shí)必須按從右至左的順序提供，即有默認(rèn)值的形參必須在形參列表的最后。
• 如果有某個(gè)形參沒(méi)有默認(rèn)值，則它左側(cè)的所有形參都不能有默認(rèn)值。
• 調(diào)用函數(shù)時(shí)，主調(diào)函數(shù)的實(shí)參與被調(diào)函數(shù)的形參按從左至右的順序進(jìn)行匹配對(duì)應(yīng)。

【示例】?函數(shù)調(diào)用示例（一）

// 假設(shè)給出如下的函數(shù)聲明：
void func(int a,int b=2,int c=3);

// 則下列函數(shù)調(diào)用中哪些是正確的？請(qǐng)解釋原因。
func(1,22,333);
func( );
func(10,20);
func(5, ,9);

【分析】

• func(1,22,333);??是正確的，調(diào)用時(shí)給出了所有實(shí)參，且參數(shù)的類型也是匹配的。
• func( );? ? ? ? ? ? ? ?是錯(cuò)誤的，聲明中參數(shù) a 沒(méi)有默認(rèn)值，調(diào)用時(shí)必須給出實(shí)參值。
• func(10,20);? ? ? ?是正確的，實(shí)參表中的兩個(gè)值 10 和 20 分別對(duì)應(yīng)于函數(shù)聲明中的形參 a 和 b ，參數(shù) c 使用默認(rèn)值 3。
• func(5, ,9);? ? ? ? ?是錯(cuò)誤的，調(diào)用時(shí)給出的實(shí)參應(yīng)該是連續(xù)排列的。

（5）引用和函數(shù)參數(shù)的傳遞

①?引用的定義

【定義】?引用相當(dāng)于給變量起了一個(gè)別名。

• 變量對(duì)應(yīng)于某個(gè)內(nèi)存地址，如果給某個(gè)變量起了別名（不需要給它另開辟內(nèi)存單元），相當(dāng)于變量和這個(gè)引用都對(duì)應(yīng)到同一地址。
• 程序中使用哪個(gè)名字都是允許的。

【格式】類型名 & 引用名 = 同類型的某變量名;

【示例】

int oneInt;
int &aname=oneInt;  // 聲明引用

/* 示例：引用和函數(shù)參數(shù)的傳遞 */
#include<iostream>
using namespace std;
int main()
{
  int oneInt=1;
  int &ref=oneInt;                                 //ref 是 oneInt 的引用，ref 等價(jià)于 oneInt
  const int &refc=oneInt;                          //定義常引用
  ref=2;                                           //修改 ref 也即修改了 oneInt
  cout<<"oneInt="<<oneInt<<","<<"ref="<<ref<<endl; //輸出 oneInt=2, ref=2
  cout<<"refc="<<refc<<endl;                       //輸出 refc=2
  oneInt=3;                                        //修改 oneInt 也即修改了 ref
  cout<<"ref="<<ref<<endl;                         //輸出 ref=3
  cout<<"refc="<<refc<<endl;                       //輸出 refc=3
  int & ref2=ref;                                  //ref2 和 ref 都是 oneInt 的引用
  cout<<"ref2="<<ref2<<endl                        //輸出 ref2=3
  //refc=5;                                        //錯(cuò)誤，不能使用常引用對(duì)所引用的變量進(jìn)行修改
  return 0;
}

②?引用在函數(shù)中的使用

? 在程序中不僅能定義變量的引用，還可以將引用用在函數(shù)中。

• 引用既可以作為函數(shù)的參數(shù)使用，也可以作為函數(shù)的返回值使用。

? 在 C++?中，函數(shù)調(diào)用時(shí)參數(shù)的傳遞有兩種方式： 傳值和 傳引用 。

• 傳值：實(shí)際上是傳遞對(duì)象的值。
• 傳引用：是傳遞對(duì)象的首地址值。

? 如果函數(shù)的形參不是引用，那么調(diào)用時(shí)實(shí)參傳遞給形參通常采用的是傳值的方式，即將實(shí)參的值拷貝給形參。

• 在函數(shù)執(zhí)行過(guò)程中，都是對(duì)這個(gè)拷貝進(jìn)行操作的，函數(shù)執(zhí)行完畢返回后，形參的值并不拷貝回實(shí)參，也就是說(shuō)函數(shù)內(nèi)部對(duì)形參的改變不會(huì)影響到函數(shù)外實(shí)參的值。

? 如果函數(shù)的形參是引用，則調(diào)用時(shí)實(shí)參傳遞給形參采用的是 傳引用 的方式。

• 函數(shù)調(diào)用時(shí)，實(shí)參對(duì)象名傳遞給形參對(duì)象名，形參對(duì)象名就成為實(shí)參對(duì)象名的別名，即形參是對(duì)應(yīng)實(shí)參的引用，它們是等價(jià)的，代表同一個(gè)對(duì)象，也可以看作是將實(shí)參的地址傳遞給了形參。
• 在函數(shù)內(nèi)部對(duì)形參的操作，都是對(duì)這個(gè)地址的內(nèi)容進(jìn)行的，相當(dāng)于對(duì)實(shí)參的值進(jìn)行了操作。所以當(dāng)函數(shù)執(zhí)行完畢返回后，實(shí)參的變化被保留下來(lái)。

#include<iostream>
using namespace std;

void SwapValue(int a,int b)
{ 
  int tmp;
  tmp=a;
  a=b;
  b=tmp;
  cout<<"在SwapVa1ue( )函數(shù)中:\t\ta="<<a<<",b="<<b<<endl;
}

void SwapRef(int & a,int & b)   // a、b值互換
{ 
  int tmp;
  tmp=a;
  a=b;
  b=tmp;
  cout<<"在SwapRef()函數(shù)中:\t\ta="<<a<<",b="<<b<<endl;
}

int main()
{ 
  int a=10,b=20;
  cout<<"數(shù)據(jù)交換前:\t\ta="<<a<<",b="<<b<<endl<<endl;
  SwapValue(a,b);
  cout<<"調(diào)用SwapVal()后:\t\ta="<<a<<",b="<<b<<endl<<endl;
  a=10;
  b=20;
  SwapRef(a,b);
  cout<<"調(diào)用SwapRef()后:\t\ta="<<a<<",b="<<b<<endl<<endl;
  return 0;
}

?

#include<iostream>
using namespace std;

int oneX=10;
int oneY=20;
int & refValue(int & x)
{
  return x;
}

int main()
{
  refValue(oneX)=30;          //返回值是引用，可以作為左值使用
  cout<<"oneX="<<oneX<<endl;  //輸出 oneX=30
  refValue(oneY)=40;          //返回值是引用的函數(shù)調(diào)用表達(dá)式，可以作為左值使用
  cout<<"oneY="<<oneY<<endl;  //輸出 oneY=40
  return 0;
}

?

（6）const 與指針共同使用

const 修飾指針變量時(shí)，基本含義如下：

1. 如果唯一的 const 位于符號(hào) * 的左側(cè)，表示指針?biāo)笖?shù)據(jù)是常量，數(shù)據(jù)不能通過(guò)本指針改變，但可以通過(guò)其他方式進(jìn)行修改；指針本身是變量，可以指向其他的內(nèi)存單元。
2. 如果唯一的 const 位于符號(hào) * 的右側(cè)，表示指針本身是常量，不能讓該指針指向其他內(nèi)存地址；指針?biāo)傅臄?shù)據(jù)可以通過(guò)本指針進(jìn)行修改。
3. 在符號(hào) * 的左右各有一個(gè) const 時(shí)，表示指針和指針?biāo)笖?shù)據(jù)都是常量，既不能讓指針指向其他地址，也不能通過(guò)指針修改所指向的內(nèi)容。?

可以簡(jiǎn)單地記住 const 的修飾規(guī)則：

• const 修飾其左側(cè)的內(nèi)容
• 如果 const 是本行的第一個(gè)標(biāo)識(shí)符，則它修飾其右側(cè)的內(nèi)容

#include<iostream>
using namespace std;
int main( )
{
  int a1=3;                  //普通變量，a1=5 是正確的
  const int a2=a1;           //數(shù)據(jù)是常量的，a2=5 是錯(cuò)誤的
  int * a3=&a1;              //普通指針指向普通變量，*a3=6 是正確的
  const int * a4=&a1;        //數(shù)據(jù)是常量的，普通指針 *a4=5 是錯(cuò)誤的
  int * const a5=&a1;        //指針是常量的，不能修改指針，但 *a5=10 是正確的
  int const * const a6=&a1;  //數(shù)據(jù)是常量的，指針也是常量的
  const int * const a7=&a1;  //數(shù)據(jù)是常量的，指針也是常量的
  return 0;
}

（7）內(nèi)聯(lián)函數(shù)?

? 為了避免這種頻繁的函數(shù)調(diào)用與返回，C++ 語(yǔ)言引入了內(nèi)聯(lián)函數(shù)的概念。

• 使用內(nèi)聯(lián)函數(shù)，編譯器在編譯時(shí)并不生成函數(shù)調(diào)用，而是將程序中出現(xiàn)的每一個(gè)內(nèi)聯(lián)函數(shù)的調(diào)用表達(dá)式直接用該內(nèi)聯(lián)函數(shù)的函數(shù)體進(jìn)行替換，就像整個(gè)函數(shù)體在調(diào)用處被重寫了一遍一樣。
• 很顯然，使用內(nèi)聯(lián)函數(shù)會(huì)使最終可執(zhí)行程序的體積增大。
• 這是以空間消耗節(jié)省時(shí)間開銷。

? 內(nèi)聯(lián)函數(shù)應(yīng)該定義在前，調(diào)用在后，定義時(shí)只需在函數(shù)頭返回值類型的前面加上 關(guān)鍵字 inline

? 內(nèi)聯(lián)函數(shù)主要 應(yīng)用于代碼量少的函數(shù)，頻繁調(diào)用

? 如果函數(shù)體中有 循環(huán)語(yǔ)句和 switch語(yǔ)句 則通常 不定義為內(nèi)聯(lián)函數(shù)

（8）函數(shù)的重載

函數(shù)重載：是指在程序的同一范圍內(nèi)聲明幾個(gè)功能類似的同名函數(shù)。 ?

實(shí)現(xiàn)函數(shù)的重載必須滿足下列條件之一：

• 參數(shù)表中對(duì)應(yīng)的參數(shù)類型不同
• 參數(shù)表中參數(shù)個(gè)數(shù)不同

1. 如果函數(shù)參數(shù)表中不同類型參數(shù)的次序不同，也符合上面所說(shuō)的條件。
2. 要注意的是，返回值類型不能用來(lái)區(qū)分函數(shù)，也就是說(shuō)，如果兩個(gè)函數(shù)的名字和參數(shù)表都是一樣的，僅僅是返回值類型不同，則這兩個(gè)函數(shù)不是重載的，編譯器認(rèn)為它們是重復(fù)定義，編譯時(shí)會(huì)報(bào)錯(cuò)。

【注意】 所謂函數(shù)重載，是指在程序的同一范圍內(nèi)聲明幾個(gè)功能類似的同名函數(shù)。

【示例】

• 例如，在同一個(gè)類中聲明 3 個(gè)求兩者中較大值的同名函數(shù)，如例 1-2 所示。
• 使用同一個(gè)函數(shù)名作為功能一樣的函數(shù)的函數(shù)名，這也符合人們的習(xí)慣。
• 針對(duì)同名的函數(shù)，分別為其編寫函數(shù)體，即可實(shí)現(xiàn)各自的功能。

/* 示例（例 1-2 ）*/
#include<iostream>
using namespace std;

int biggerInt(int x,int y)               //返回兩個(gè) int 型數(shù)中的較大者
{
  if(x>y) return x;
  else return y;
}

float biggerFloat(float x,float y)       //返回兩個(gè) float 型數(shù)中的較大者
{
  if(x>y) return x;
  else return y;
}

double biggerDouble(double x,double y)   //返回兩個(gè) double 型數(shù)中的較大者
{ 
  if(x>y) return x;
  else return y;
}

void main()
{
  int a=5,b=8;
  cout<<biggerInt(a,b)<<endl;
}

#include<iostream>
using namespace std;

int abs(int n)
{
  return(n<0?-n:n);
}

float abs(float f)
{
  if(f<0) f=-f;
  return f;
}

double abs(double d)
{
  if(d<0) return -d;
  return d;
}

void main()
{
  int a=-6;
  cout<<abs(a)<<endl;
}

【注意】編譯階段，程序還沒(méi)有執(zhí)行，所以并不知道返回值是什么，更加確定不了它的類型，所以編譯器并不能根據(jù)返回值確定該調(diào)用哪個(gè)函數(shù)。

【示例】錯(cuò)誤的重載函數(shù)

float add(int, float);    //將整數(shù)和浮點(diǎn)數(shù)相加，返回浮點(diǎn)數(shù)
int add(int, float);      //將整數(shù)和浮點(diǎn)數(shù)相加，返回整數(shù)，錯(cuò)誤!

【注意】 采用引用參數(shù)也不能區(qū)分函數(shù)

【示例】錯(cuò)誤的重載函數(shù)

void print(double);
void print(double&); //錯(cuò)誤！

【示例】調(diào)用重載函數(shù)

int xI=10,yI=20;
float xF=30,yF=40;
double xD=50,yD=60;
cout<<bigger(xI,yI)<<endl;
cout<<bigger(xF,yF)<<endl;
cout<<bigger(xD,yD)<<endl;

【分析】根據(jù)函數(shù)重載的規(guī)則：

• bigger(xI,yI)?調(diào)用的是?int bigger(int,int) 函數(shù)
• bigger(x,yF)?調(diào)用的是?float bigger(float,float)?函數(shù)
• bigger(xD,yD)?調(diào)用的是?double bigger(double,double)?函數(shù)

【示例】調(diào)用函數(shù)時(shí)進(jìn)行必要的類型提升

double bigger(double x,double y)
{
  if(x>y) return x;
  else return y;
}
int xI=10,yI=20;
float xF=30,yF=40;
double xD=50,yD=60;
cout<<bigger(xI,yF)<<endl;

【示例】調(diào)用重載函數(shù)時(shí)的二義性

• 若定義了重載函數(shù)?Sum( )，如下所示：

int Sum(int a,int b,int c=0);
int Sum(int a,int b);

• 則以下函數(shù)調(diào)用語(yǔ)句將導(dǎo)致編譯錯(cuò)誤：

Sum(1,2);

【分析】因?yàn)榫幾g器不知道是應(yīng)該以 (1 ， 2 ， 0)? 作為參數(shù)調(diào)用第一個(gè) Sum( )? 函數(shù)，還是以 (1,2)? 作為參數(shù)調(diào)用第二個(gè)? Sum( )? 函數(shù)，即 產(chǎn)生二義性 。在設(shè)計(jì)程序時(shí)，應(yīng)該避免這種情況的發(fā)生。

（9）指針和動(dòng)態(tài)內(nèi)存分配

1. 指針變量中保存的是一個(gè)地址，有時(shí)也稱指針指向一個(gè)地址。
2. 數(shù)組的長(zhǎng)度是聲明數(shù)組時(shí)指定的，在整個(gè)程序運(yùn)行過(guò)程中通常是不變化的。C++ 語(yǔ)言不允許定義元素個(gè)數(shù)不確定的數(shù)組。
3. 在 C++ 語(yǔ)言中，使用 new 運(yùn)算符實(shí)現(xiàn)動(dòng)態(tài)內(nèi)存分配。?
4. 使用?new?運(yùn)算符動(dòng)態(tài)申請(qǐng)的內(nèi)存空間，需要在使用完畢釋放。C++?提供了?delete?運(yùn)算符，用來(lái)釋放動(dòng)態(tài)分配的內(nèi)存空間。

• delete?運(yùn)算符的基本用法如下： delete 指針;

• delete?運(yùn)算符后面的指針必須是指向動(dòng)態(tài)分配的內(nèi)存空間的，否則運(yùn)行時(shí)很可能會(huì)出錯(cuò)

【示例】指針變量中保存的是一個(gè)地址，有時(shí)也稱指針指向一個(gè)地址，若有以下的定義：?

int a=100,*p=&a;

【分析】

• 指針 p 指向整型變量 a，p 中保存 a 的地址，而不是值 100 。
• p 指向的地址中的值是 100。
• 地址與地址中的值不要混淆。

【示例】?數(shù)組的長(zhǎng)度是聲明數(shù)組時(shí)指定的，在整個(gè)程序運(yùn)行過(guò)程中通常是不變化的。C++語(yǔ)言不允許定義元素個(gè)數(shù)不確定的數(shù)組。例如：

int n;
int a[n];  //在有些編譯環(huán)境下，這種定義是不允許的，因?yàn)?n 未知

【示例】 在 C++ 語(yǔ)言中，使用 new 運(yùn)算符實(shí)現(xiàn)動(dòng)態(tài)內(nèi)存分配。

• 例如，可以寫如下的語(yǔ)句：

p=new T;

其中，T 是任意類型名，p 是類型為 T* 的指針。

• 這樣的語(yǔ)句會(huì)動(dòng)態(tài)分配出一片大小為 sizeof(T) 字節(jié)的內(nèi)存空間，并且將該內(nèi)存空間的起始地址賦值給指針p。例如：

int * p;
p=new int;
*p=5;

第 2 行語(yǔ)句動(dòng)態(tài)分配了有 4 個(gè)字節(jié)大小的內(nèi)存空間，p 指向這個(gè)空間的首地址，之后通過(guò)指針 p 可以讀寫該內(nèi)存空間。第 3 行語(yǔ)句是向這個(gè)空間中存入數(shù)值 5 。

• 使用 new 運(yùn)算符還可以動(dòng)態(tài)分配一個(gè)任意大小的數(shù)組：

p=new T[N];

其中，T 是任意類型名，p 是類型為 T* 的指針，N 代表數(shù)組 “元素個(gè)數(shù)” ，可以是任何的值為正整數(shù)的表達(dá)式。數(shù)組中元素的類型是 T 類型。這條語(yǔ)句動(dòng)態(tài)分配了 N*sizeof(T) 個(gè)字節(jié)的內(nèi)存空間，指針 p 指向這段空間的首地址。

【示例】動(dòng)態(tài)分配整型數(shù)組

int * pArray;               //指向數(shù)組的指針
int i = 5;
pArray = new int [i*20];    //分配了 100 個(gè)元素的整型數(shù)組
pArray[0] = 20;             //數(shù)組的第一個(gè)值
pArray [99] = 30;           //數(shù)組的最后一個(gè)值

【分析】

• 數(shù)組的下標(biāo)從?0?開始，含?n?個(gè)元素的數(shù)組的下標(biāo)范圍是從?0?n-1。
• 超出這個(gè)范圍的值都會(huì)導(dǎo)致數(shù)組下標(biāo)越界。例如，上述代碼中定義的數(shù)組?pArray?，當(dāng)使用pArray[-1]?或是 pArray[100]?時(shí)，下標(biāo)會(huì)越界。
• 不過(guò)在編譯時(shí)，對(duì)于數(shù)組越界的錯(cuò)誤并不會(huì)提示，而顯示編譯正確。運(yùn)行時(shí)，會(huì)得到意料之外的結(jié)果。

【示例】?使用 new?運(yùn)算符動(dòng)態(tài)申請(qǐng)的內(nèi)存空間，需要在使用完畢釋放。C++提供了delete運(yùn)算符，用來(lái)釋放動(dòng)態(tài)分配的內(nèi)存空間。delete運(yùn)算符的基本用法如下：

• delete 指針;

delete?運(yùn)算符后面的指針必須是指向動(dòng)態(tài)分配的內(nèi)存空間的，否則運(yùn)行時(shí)很可能會(huì)出錯(cuò)， 釋放指針時(shí)出錯(cuò)示例如下：

int oneInt=6;
int * p=&ontInt;
cout<<*p<<endl;
delete p;          //出錯(cuò)，p 是引用，不是動(dòng)態(tài)分配的
int * q=new int;
*q=8;
cout<<*q<<endl;
delete q;          //正確，q 指向動(dòng)態(tài)分配的空間

【分析】?

• 指針?p?和?q?都指向一個(gè)整型變量，但指針?p?指向的空間并不是使用?new?運(yùn)算符分配的，所以不能使用?delete?釋放
• 而指針?q?指向的空間是使用?new?分配的，所以使用完畢，通過(guò)?delete?進(jìn)行釋放

• 如果是使用?new?運(yùn)算符動(dòng)態(tài)分配了一個(gè)數(shù)組，那么釋放該數(shù)組時(shí)，語(yǔ)句為：delete [ ] 指針;

• 例如，釋放上述代碼中分配的數(shù)組空間的語(yǔ)句是?“delete [ ] pArray;”?

（10）用 string 對(duì)象處理字符串?

• C++ 標(biāo)準(zhǔn)模板庫(kù)中提供了 string 數(shù)據(jù)類型，專門用于處理字符串。
• string是一個(gè)類，這個(gè)類型的變量稱為 “string對(duì)象”? 。

①?string 對(duì)象的使用

要在程序中使用 string 對(duì)象，必須在程序中包含頭文件 string ，即在程序的最前面，要加上如下語(yǔ)句：

#include<string>

②?string 對(duì)象的聲明

聲明一個(gè) string 對(duì)象，與聲明普通變量是類似的，格式如下：

string 變量名;?

【示例】?

• 聲明?string?對(duì)象?str1?，值為空

• 聲明?string?對(duì)象?city?，并使用字符串常量進(jìn)行初始化

• 聲明?string?對(duì)象?str2?，并使用字符串變量進(jìn)行初始化

string str1;                    //聲明 string 對(duì)象 str1，值為空
string city="Beijing";          //聲明 string 對(duì)象 city，并使用字符串常量進(jìn)行初始化
string str2=city;               //聲明 string 對(duì)象 str2，并使用字符串變量進(jìn)行初始化
cout<<"str1="<<str1<<"."<<endl;
cout<<city<<","<<str2<<endl;

【示例】使用字符數(shù)組對(duì)?string?變量進(jìn)行初始化

char name[ ]="C++程序";
string s1=name;

【示例】聲明一個(gè)?string?對(duì)象數(shù)組，即數(shù)組中每個(gè)元素都是字符串

string citys[ ]={"Beijing","Shanghai","Tianjin","Chongqing"};
cout<<citys[1]<<endl;                       //輸出 Shanghai，數(shù)組下標(biāo)從 0 開始
cout<<sizeof(citys)/sizeof(string)<<endl;   //輸出數(shù)組元素個(gè)數(shù)

【分析】

• 最后一行語(yǔ)句將輸出數(shù)組元素個(gè)數(shù)。
• citys?是?string?對(duì)象數(shù)組
• sizeof(citys)?是整個(gè)數(shù)組占用的空間大小
• sizeof(string) 是每個(gè)?string?對(duì)象的大小
• 所以?sizeof(citys) / sizeof(string)?表示的是數(shù)組元素個(gè)數(shù)

③?string 對(duì)象的操作

【說(shuō)明】 string?對(duì)象可以使用? cin? 和? cout? 進(jìn)行輸入和輸出，實(shí)際上，到目前為止，已經(jīng)使用了很多這樣的示例。

【示例】

string s1,s2;
cin>>s1>>s2;
cout<<s1<<","<<s2<<endl;

【說(shuō)明】

• string對(duì)象之間可以互相賦值，也可以用字符串常量和字符數(shù)組的名字對(duì)string對(duì)象進(jìn)行賦值。
• 賦值時(shí)不需要考慮被賦值的對(duì)象是否有足夠的空間來(lái)存儲(chǔ)字符串。

【示例】

string s1,s2="OK";
s1="China";
s2=s1;          // s1 和 s2 表示的字符串不等長(zhǎng)，賦值后 s2 的內(nèi)容和 s1 相同
cout<<"s1="<<s1<<"s2="<<s2<<endl;

#include<iostream>
#include<string>
using namespace std;
void main()
{
  string s1, s2; 
  s1="C++程序";
  s2=s1;
  string s3;
  cout<<"s3= "<<s3<<endl;     //輸出 s3=
  s3=s1+s2;
  cout<<s1+s2<<endl;          //輸出 C++程序C++程序
  cout<<"s3="<<s3<<endl;      //輸出 s3=C++程序C++程序
  s3+="de";
  cout<<"s3="<<s3<<endl;      //輸出 s3=C++程序C++程序de
  bool b=s1<s3;               //b 為 true
  cout<<"bool="<<b<<endl;     //輸出 bool=1
  char c=s1[2];               //c 為 '+'，下標(biāo)從 0 開始計(jì)算
  cout<<"c="<<c<<endl;        //輸出 c=+
  cout<<s1[2]<<endl;          //輸出 +
  char arrstr[]="Hello";
  s3=s1+arrstr; 
  cout<<s3<<endl;             //輸出 C++程序Hello
}

?

#include<iostream>
#include<string>
using namespace std;
int main()
{
  string str;      //未初始化，空串
  if(str.empty())
      cout<<"str is NULL."<<",length="<<str.length()<<endl;
  else
      cout<<"str is not NULL."<<endl;
  str=str.append("abcdefg");
  cout<<"str is "<<str<<"，size="<<str.size()<<endl;
  const char *p=str.c_str();
  cout<<"p="<<p<<endl;
  cout<<"find:"<<str.find("de",0)<<endl;   //查找成功，3
  cout<<"find:"<<str.find("de",4)<<endl;   //查找失敗
  string str1=str.insert(4,"123");
  cout<<str1<<endl;
  return 0;
}

?文章來(lái)源地址http://www.zghlxwxcb.cn/news/detail-469892.html

三、C++ 語(yǔ)言的程序結(jié)構(gòu)

1. C++ 程序以?.cpp?作為文件擴(kuò)展名，文件中包含若干個(gè)類和若干個(gè)函數(shù)。
2. 程序中必須有且僅有一個(gè)主函數(shù) main( )，這是程序執(zhí)行的總?cè)肟凇?/span>
3. 主函數(shù)也稱為主程序。
4. 程序從主函數(shù) main( ) 的開始處執(zhí)行，主函數(shù)可以在任何地方出現(xiàn)，按照其控制結(jié)構(gòu)，一直執(zhí)行到結(jié)束。
5. 主函數(shù)中可以調(diào)用程序中定義的其他函數(shù)，但其他函數(shù)不能調(diào)用主函數(shù)。
6. 主函數(shù)僅是系統(tǒng)為執(zhí)行程序時(shí)所調(diào)用的。

程序的結(jié)束通常是遇到了以下兩種情形之一：

• 在主函數(shù)中遇到 return 語(yǔ)句
• 執(zhí)行到主函數(shù)最后面的括號(hào) }

C++ 程序中，仍沿用 C 語(yǔ)言的注釋風(fēng)格，即注釋有以下兩種形式：

• 多行注釋：從?/* 開始，到 */ 結(jié)束，這之間的所有內(nèi)容都視作注釋
• 單行注釋：從?// 直到行尾，都是注釋

到了這里，關(guān)于【C++ 程序設(shè)計(jì)】第 1 章：C++ 語(yǔ)言簡(jiǎn)介的文章就介紹完了。如果您還想了解更多內(nèi)容，請(qǐng)?jiān)谟疑辖撬阉鱐OY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章，希望大家以后多多支持TOY模板網(wǎng)！