C++的基礎知識點有哪些

這篇文章主要介紹“C++的基礎知識點有哪些”，在日常操作中，相信很多人在C++的基礎知識點有哪些問題上存在疑惑，小編查閱了各式資料，整理出簡單好用的操作方法，希望對大家解答”C++的基礎知識點有哪些”的疑惑有所幫助！接下來，請跟著小編一起來學習吧！

一、標簽！標簽！

快快為你的程序貼上C++的標簽，讓你看起來很像個合格的C++用戶……

1.注釋（comment）

C++的注釋允許采取兩種形式。***種是傳統C采用的/*和*/，另一種新采用的則是//，它表示從//至行尾皆為注釋部分。讀者朋友完全可以通過//使你的代碼帶上C++的氣息，如test0l：

//test01.cpp  #include <iostream.h>  //I'm a C++user!  //&hellip;and C is out of date.  void main()  {  cout<<"Hello world!\n"; //prints a string  }  Hello-world！

如果你嘗試著在test0l. exe中找到這些高級的注釋，很簡單，它們不會在那里的。

2. cincout

你可能從test0l中嗅出什么味兒來了，在C++中，其次的貴族是cout，而不是很老土的printf （ ）。左移操作符&lsquo;<<&rsquo;的含義被重寫，稱作“輸出操作符”或“插入操作符”。你可以使用&lsquo;<<&rsquo;將一大堆的數據像糖葫蘆一樣串起來，然后再用cout輸出：

cout << "ASCII code of "<< 'a' << " is:" <<97;   ASCII code of a is:97

如何來輸出一個地址的值呢?在C中可以通過格式控制符”%p”來實現，如:

printf ("%p，&i);

類似地，C++也是這樣:

cout << & i;

但對字符串就不同啦!因為:

char * String="Waterloo Bridge";  cout << String; //prints &lsquo;Waterloo Bridge'

只會輸出String的內容。但方法還是有的，如采取強制類型轉換:

cout<<(void *)String;

cin采取的操作符是&rsquo;>>&rsquo;，稱作“輸入操作符”或“提取操作符”。在頭文件iostream.h中有cin cout的原型定義，cin語句的書寫格式與cout的完全一樣:

cin>>i; //ok  cin>>&i; //error. Illegal structure operation

看到了?別再傻傻地送一個scanf()常用的&rsquo;&&rsquo;地址符給它。

C++另外提供了一個操縱算子endl，它的功能和&rsquo;\n&rsquo;完全一樣，如test0l中的cout語句可改版為:

cout << ”Hello world!”<

3.即時聲明

這是筆者杜撰的一個術語，它的原文為declarations mixed with statements，意即允許變量的聲明與語句的混合使用。傳統C程序提倡用戶將聲明和語句分開，如下形式:

int i=100;  float f; //declarations   i++;  f=1.0/i; //statements

而C拋棄這點可讀性，允許用戶采取更自由的書寫形式：

int i=100;  i++;  float f =1. 0/i;

即時聲明常見于for循環語句中：

for(int i = 0; i < 16; i++)  for(int j = 0; j < 16; j++)  putpixel(j i Color[i][j]);

這種形式允許在語句段中任點聲明新的變量并不失時機地使用它（而不必在所有的聲明結束之后）。

特別地，C++強化了數據類型的類概念，對于以上出現的“int i=1 j=2；”完全可以寫成：int i（1） j （2）；再如：

char * Stringl("Youth Studio.”);  char String2[]("Computer Fan.“);

這不屬于“即時聲明”的范疇，但這些特性足以讓你的代碼與先前愚昧的C產品區別開來。

4.作用域（scope）及其存取操作符（scope qualifier operator）

即時聲明使C語言的作用域的概念尤顯重要，例如以下語句包含著一條錯誤，因為ch變量在if塊外失去了作用域。

if(ok)  char ch='!';  else ch='?'; //error. access outside condition

• 作用域對應于某一變量的生存周期，它通常表現為以下五種:

• 塊作用域：開始于聲明點，結束于塊尾，塊是由{}括起的一段區域

• 函數作用域：函數作用域只有語句標號，標號名可以和goto語句一起在函數體任何地方

• 函數原型作用域：在函數原型中的參量說明表中聲明的標識符具有函數原型作用域

• 文件作用域：在所有塊和類的外部聲明的標識符(全局變量)具有文件作用域

• 類作用域：類的成員具有類作用域

具有不同作用域的變量可以同名，如test02:

//test02.cpp  #include <iostream.h>  int i=0;  void main()  {  cout << i << ' '; //global 'int i' visible  {  float i(0.01); //global 'int i' overrided  cout<< i << ' ';  }  cout<<i<<endl; //global 'int i' visible again  }  //輸出結果 0 0.01 0

編譯器并未給出錯誤信息。

作用域與可見性并不是同一概念，具有作用域不一定具有可見性，而具有可見性一定具有作用域。

在test02中，float i的使用使全局int i失去可見性，這種情形被稱作隱藏（override）。但這并不意味著int i失去了作用域，在main（）函數運行過程中，int i始終存在。

有一種辦法來引用這丟了名份的全局i，即使用C++提供的作用域存取操作符：：，它表示引用的變量具有文件作用域，如下例程：

//test03.cpp  #include <iostream.h>  enum {boy girl};  char i = boy;  void main()  {  {  float i(0.01);  cout << "i=" << i << endl;  ::i=girl; //modify global 'i'  }  cout << "I am a " << (i ? "girl." : "boy.");  }  輸出結果：  i=0.01  I am a girl.

在上例中，通過：：操作符，第8行語句偷偷地改寫了i所屬的性別。更妙的是，：：之前還可以加上某些類的名稱，它表示引用的變量是該類的成員。

5. new delete

許多C用戶肯定不會忘記alloc（）和free（）函數族，它們曾經為動態內存分配與釋放的操作做出了很大的貢獻，如：

char *cp = malloc(sizeof(char));  int *ip=calloc(sizeof(int) 10);  free(ip);  free(cp);

C++允許用戶使用這些函數，但它同時也提供了兩個類似的操作符new和delete，它們分別用來分配和釋放內存，形式如下：

p = new TYPE；  delete p；

因此以上的cp操作可改版為：

char*cp=new char；  delete cp；

new delete操作符同樣亦可作用于C中的結構變量，如：

struct COMPLEX*cp = new struct COMPLEX；  delete cp；

當不能成功地分配所需要的內存時，new將返回NULL.對于字符型變量可以如下初始化：

char ch（'A'）； //char ch='A'

對應地，new可以同時對變量的值進行初始化，如：

char p=new char （'A‘）； //cp='A' new

不需要用戶再使用sizeof運算符來提供尺寸，它能自動識別操作數的類型及尺寸大小，這雖然比malloc）函數聰明不了多少，但起碼使用起來會比它方便得多。當然，正如calloc（）函數，new也可以用于數組，形式如下：

p = new TYPE[Size] ；

對應的內存釋放形式：

delete [] p；

同理首例中ip操作可以改版為：

int * ip=new int[10]；  delete [] ip；

用new分配多維數組的形式為：

p = new TYPE [c0] [c1]…… [cN]；

從來沒有太快活的事情，例如以下使用非法：

int***ip2=（int***）new int[m] [n][k]； //error. Constant expression required int***ip 1=（int***）new int[m][2][81； //ok

C++最多只允許數組***維的尺寸（即c0）是個變量，而其它的都應該為確定的編譯時期常量。使用new分配數組時，也不能再提供初始值：

char*String =new char[ 20] （"Scent of a Woman"）；   //error： Array allocated using 'new' may not have an initializer

6.引用（reference）

（1）函數參數引用以下例程中的Swap（）函數對數據交換毫無用處：

//test04. cpp  #include <iostream.h>  void Swap(int va int vb)  {  int temp=va;  va=vb;  vb=temp;  cout << "&va=" << &va << "&vb=" << &vb << endl;  }  void main()  {  int a(1) b(2);  cout << "&a=" << &a << "&b=" << &b << endl;  Swap(a b);  cout << "a=" << a << " b=" << b << endl;  }

輸出結果：

&a=0x0012FF7C&b=0x0012FF78 &va=0x0012FF24&vb=0x0012FF28 a=1 b=2c

語言對參數的調用采取拷貝傳值方式，在實際函數體內，使用的只是與實參等值的另一份拷貝，而并非實參本身（它們所占的地址不同），這就是Swap（）忙了半天卻什么好處都沒撈到的原因，它改變的只是地址0x0012FF24和0x0012FF28處的值。當然，可采取似乎更先進的指針來改寫以上的Swap （）函數：

//test05. cpp  #include <iostream.h>  void Swap(int * vap int * vbp)  {  int temp = *vap;  *vap = *vbp;  *vbp = temp;  cout << "vap=" << vap << "vbp=" <<vbp << endl;  cout << "&vap=" << &vap << "&vbp=" << &vbp << endl;  }  void main()  {  int a(1) b(2);  int * ap = &a * bp = &b;  cout << "ap=" << ap << "bp=" << bp << endl;  cout << "&ap=" << &ap << "&bp=" << &bp << endl;  Swap(ap bp);  cout << "a=" << a << "b=" << b <<endl;  }  ap=0x0012FF7Cbp=0x0012FF78  &ap=0x0012FF74&bp=0x0012FF70  vap=0x0012FF7Cvbp=0x0012FF78  &vap=0x0012FF1C&vbp=0x0012FF20  a=2b=1

在上例中，參數的調用仍采取的是拷貝傳值方式，Swap（）拷貝一份實參的值（其中的內容即a b的地址），但這并不表明vapvbp與實參apbp占據同一內存單元。

對實際數據操作時，傳統的拷貝方式并不值得歡迎，C++為此提出了引用方式，它允許函數使用實參本身（其它一些高級語言，如BASIC FORTRAN即采取這種方式）。以下是相應的程序：

//test06. cpp  #include <iostream.h>  void Swap(int & va int & vb)  {  int temp=va;  va=vb;  vb=temp;  cout << "&va=" << &va << "&vb=" << &vb << endl;  }  void main()  {  int a(1) b(2);  cout << "&a=" << &a << "&b=" << &b << endl;  Swap(a b);  cout << "a=" << a << "b=" << b << endl;  }

輸出結果：

&a=0x0012FF7C&b=0x0012FF78  &va=0x0012FF7C&vb=0x0012FF78  a=2b=1

很明顯，a b與vavb的地址完全重合。對int&的寫法別把眼睛瞪得太大，你頂多只能撇撇嘴，然后不動聲色地說：“就這么回事！加上&就表明引用方式唄！”

（2）簡單變量引用簡單變量引用可以為同一變量取不同的名字，以下是個例子：

int Rat；int & Mouse=Rat；

這樣定義之后，Rat就是Mouse（用中文說就是：老鼠就是老鼠），這兩個名字指向同一內存單元，如：

Mouse=Mickey； //Rat=Mickey

一種更淺顯的理解是把引用看成偽裝的指針，例如，Mouse很可能被編譯器解釋成：*（& Rat），這種理解可能是正確的。

由于引用嚴格來說不是對象（？！），在使用時應該注意到以下幾點：

①引用在聲明時必須進行初始化；

②不能聲明引用的引用；

③不能聲明引用數組成指向引用的指針（但可以聲明對指針的引用）；

④為引用提供的初始值必須是一個變量。

當初始值是一個常量或是一個使用const修飾的變量，或者引用類型與變量類型不一致時，編譯器則為之建立一個臨時變量，然后對該臨時變量進行引用。例如：

int & refl = 50; //int temp=50 &refl=temp  float a=100.0;  int & ref2 = a; / / int temp=a&ref2=temp

（3）函數返回引用函數可以返回一個引用。觀察程序test07：

//test07.cpp  #include <iostream.h>  char &Value (char*a int index)  {  return a[index];  }  void main()  {  char String[20] = "a monkey!";  Value(String 2) = 'd';  cout << String << endl;  }  輸出結果：a donkey!

這個程序利用函數返回引用寫出了諸如Value （String 2） ='d&lsquo;這樣令人費解的語句。在這種情況下，函數允許用在賦值運算符的左邊。

函數返回引用也常常應用于操作符重載函數。

7.缺省參數（default value）

從事過DOS環境下圖形設計的朋友（至少我在這個陷阱里曾經摸了兩年時間）肯定熟悉initgraph（）函數，它的原型為：void far initgraph（int far *GraphDriver int far*GraphMode char far*DriverPath）；也許你會為它再定做一個函數：

void InitGraph(int Driver int Mode)  {  initgraph(& Driver &Mode ““);  }

一段時間下來，你肯定有了你最鐘情的調用方式，例如你就喜歡使用640 * 480 * 16這種工作模式。

既然如此，你完全可以將函數InitGraph （ ）聲明成具有缺省的圖形模式參數，如下：

void InitGraph（int Driver = VGA int Mode = VGAHI）；

這樣，每次你只需簡單地使用語句

InitGraph （）；

即可進入你所喜愛的那種模式。當然，當你使用

InitGraph （CGA CGAHI ）；

機器也會毫不猶豫地切入到指定的CGAHI模式，而與正常的函數沒有兩樣。

這就是缺省參數的用法！為了提供更豐富的功能，一些函數要求用戶提供更多的參數（注意到許多Windows程序員的煙灰缸旁邊都有一本很厚很厚的Windows函數接口手冊），而實際上，這些參數中的某幾項常常是被固定引用的，因此，就可以將它們設定為缺省參數，例如以下函數：

void Putpixel（int x int y int Color=BLACK char Mode =COPY_PUT）；

將可能在（（x y）處以Color顏色、Mode模式畫一個點，缺省情況下，顏色為黑色，寫點模式為覆蓋方式。

以下對函數的調用合法：

Putpixel （100 100）； // Putpixel（100 100 BLACK COPY _PUT）  PutPixel （100 100 RED）； // PutPixel（100 100 RED COPY_ PUT）  PutPixel（100 100 RED XOR_PUT）；

而以下調用形式并不合法：

Putpixel（）；  Putpixel （100） ；  Putpixel（100 100 XOR_PUT）；

前兩種形式缺少參數，因為x、y值并沒有缺省值；第三種形式則天真地以為編譯器會將其處理成：

PutPixel （100 100 BLACK XOR_PUT）；

并且不會產生任何二義性問題，不幸的是，C++并不贊成這樣做。

作為一條經驗，缺省參數序列中最容易改變其調用值的應盡量寫在前面，最可能使用其缺省值的（即最穩定的）置于后端。如果將以上函數原型聲明成如下形式：

void Putpixel（int Color = BLACK char Mode = COPY_PUT int x=100 int y=100）；

到此，關于“C++的基礎知識點有哪些”的學習就結束了，希望能夠解決大家的疑惑。理論與實踐的搭配能更好的幫助大家學習，快去試試吧！若想繼續學習更多相關知識，請繼續關注億速云網站，小編會繼續努力為大家帶來更多實用的文章！