C++入門基礎篇：域、C++的輸入輸出、缺省參數、函數重載、引用、inline、nullptr

本篇文章是對C++學習前期的一些基礎部分的學習分享，希望也能夠對你有所幫助。

那咱們廢話不多說，直接開始吧！

1.第一個C++程序

2. 域

3. namespace

3.1 namespace的作用

3.2 namespace的定義

3.3 namespace使用說明

4.C++的輸入和輸出

4.1?C++ 的輸入輸出流庫

4.2?標準輸入輸出對象及其特點

4.3?輸入輸出運算符

4.4?C++ 輸入輸出的優勢

4.5?涉及的面向對象知識

4.6?命名空間的使用

4.7?與的關系

5. 缺省參數

5.1 缺省參數的定義

5.2 缺省參數的類別

5.3?帶缺省參數的函數調用規則：

5.4?函數聲明和定義分離時的缺省參數設置：

6. 函數重載

7. 引用

7.1 引用的概念域定義

7.2 引用的特性

7.3 引用的使用

7.3.1 引用傳參

7.3.2 引用用作返回值

7.4 const引用

7.4.1?引用const對象的規則

7.4.2 臨時對象的定義

7.4.3?臨時對象與權限放大問題

7.5 指針與引用的關系

7.5.1 語法概念層面

7.5.2 初始化要求

7.5.3?指向對象的可變性

7.5.4 訪問指向對象的方式

7.5.5?在sizeof操作中的含義

7.5.6 安全性考量

8. inline

8.1 內聯函數概述

8.2 編譯器對inline的處理

8.3?與 C 語言宏函數的對比

8.4?VS 編譯器中 debug 版本的 inline 設置

8.5?inline 函數聲明和定義的注意事項

9. nullptr

9.1 NULL存在的問題

9.2 nullptr的性質

9.3 nullptr的優勢

1.第一個C++程序

與C語言類似，C++夢開始的地方也是Hello World，下面是與C語言的代碼比較：

//C++
#include <iostream>
using namespace std;int main()
{cout<<"Hello World"<<endl;return 0;
}//C
#include<stdio.h>int main()
{printf("Hello World");return 0;
}

這個頭文件包含我能理解，但是下面那行using namespace std是個什么玩意兒？

在講它之前，我們需要先學習一個概念：域

2. 域

域是程序中變量、函數、類等實體可見性和生命周期的范圍。C++ 中有不同的域，如：

全局域（在所有函數和類之外定義的變量等所處的域）、

局部域（在函數內部定義的變量所處的域）、

類域（類內部定義的成員變量和成員函數所處的域）以及

命名空間域等。

域規則決定了在程序的不同部分如何訪問和使用這些實體。

知道cpp輸出hello world的底層邏輯后你應該就能夠理解上面這句話了：

標準庫其中一個頭文件叫iostream，iostream中有個定義好了的命名空間叫std，cout則是std這個域中的一個對象，當系統在編譯時檢索到cout，這時便其要到std這個命名空間中尋找其運行邏輯，而所輸出的hello world則是運行邏輯完成后帶來的結果。

3. namespace

namespace則是命名空間域

3.1 namespace的作用

無論是c還是cpp，都存在大量的變量、函數以及類，它們的名稱都存在于全局作用域中，如果創作者在定義自己的變量時與這些名字一樣便會產生命名沖突：

如下面這段代碼：

 #include <stdio.h>int rand = 10;int main()
{printf("%d\n", rand);return 0;}

這段代碼會編譯報錯：error C2365: “rand”: 重定義；已有的定義是 “ 函數 ”

且這全局作用域中的變量實在太多，產生這種沖突的普遍性可想而知，本來上班就夠煩的了還老是來這么一出程序員能樂意啊？

namespace就是為了避免這種沖突而生的~

3.2 namespace的定義

定義命名空間需要用到namespace關鍵字，后面跟上一對{}即可，括號中的即為命名空間的成員。其中可以定義函數、變量、類型等。

namespace本質便是定義出一個和全局域完全獨立出來的域，在不同的域中可以定義同名變量，因此任何與全局變量命名沖突的變量只要我們在命名空間里再定義一遍，在域隔離的作用下就不會再有命名沖突報錯了。

當然在定義了命名空間后，我們還需要對變量進行指定訪問才可以正常使用該變量，如：

#include <stdio.h>
#include <stdlib.h>namepace H
{int rand;int a;
}int main()
{//這里more訪問的全局的rand函數指針printf("%p\n", rand);//這里指定訪問的H命名空間中的randprintf("%d\n",H::rand);return 0;
}

H::rand則是指定訪問命名空間H中的rand，不難看出指定訪問的格式為：

命名空間名::變量名

若沒寫命名空間名訪問的全局域的變量，就是說rand和::rand都表示的是函數名稱，當然這種情況下直接省略該符號就好了。

3.3 namespace使用說明

a.只能在全局定義

b.可以嵌套定義

namespace H
{int a;int b;namespace h{int c;char c;}
}int main()
{//指定訪問命名空間h中的成員cprintf(%d\n",H::h::c);return 0;
}

c.同一個項目中工程中的多個同名的namespace會被認為是同一個，不會產生沖突，但要注意兩個同名的namespace不能夠對同一個成員重復定義，否則會報錯，如：

namespace H
{int a=10;
}namespace H
{
int a=20;
}

d.using+命名空間名：：變量名是某個命名空間的成員展開，這樣在后續訪問其中的變量時變不需要再用 : :了，項目中需要經常訪問且不存在沖突的成員推薦這種方式。

namespace H
{int a;int b;namespace h{int c;char c;}
}using H::b;
using H::h::c;int main()
{printf("%d\n",b);printf("%d\n",c);return 0;
}

e.展開整個命名空間：using namespace+命名空間名

現在我們就知道，using namespace std就是展開std命名空間的意思

但是，項目中不推薦這么操作，沖突風險大（兩個人都展開，結果有相同的變量那不炸了嗎...）

4.C++的輸入和輸出

4.1?C++ 的輸入輸出流庫 <iostream>

<iostream>?是標準的輸入、輸出流庫，是?InputOutputStream?的縮寫，該庫定義了標準的輸入和輸出對象。

4.2?標準輸入輸出對象及其特點

std::cin：
- 是?istream?類的對象。
- 主要面向窄字符（類型為?char?的字符）的標準輸入流，用于從標準輸入設備（如鍵盤）讀取數據。
std::cout：
- 是?ostream?類的對象。
- 主要面向窄字符的標準輸出流，用于向標準輸出設備（如顯示器）輸出數據。
std::endl：
- 是一個函數。
- 在流插入輸出時，其作用相當于插入一個換行字符并刷新緩沖區，保證輸出的內容能及時顯示。

4.3?輸入輸出運算符

<<：
- 是流插入運算符，在 C++ 中用于向輸出流插入數據，例如?std::cout << "Hello, World!";。
- 在 C 語言中還可用于位運算左移操作。
>>：
- 是流提取運算符，在 C++ 中用于從輸入流提取數據，例如?std::cin >> variable;。
- 在 C 語言中還可用于位運算右移操作。

4.4?C++ 輸入輸出的優勢

相較于 C 語言中的?printf?和?scanf?函數，C++ 的輸入輸出使用更方便：

不需要手動指定格式，能自動識別變量類型，例如?std::cout << 123;?會自動識別 123 是整數并正確輸出。

本質是通過函數重載實現自動類型識別，后續會詳細講解。

重要的是 C++ 的流能更好地支持自定義類型對象的輸入輸出，方便對自定義類型進行輸入輸出操作。

4.5?涉及的面向對象知識

C++ 的 IO 流涉及眾多面向對象的知識，包括類和對象、運算符重載、繼承等。

現階段僅作簡單介紹，后續會有專門章節詳細講解 IO 流庫的細節，深入探討這些面向對象的知識在 IO 流中的應用。

4.6?命名空間的使用

cout、cin、endl?等都屬于 C++ 標準庫。

C++ 標準庫都放置在名為?std（代表?standard）的命名空間中。

因此在使用這些對象和函數時，需要通過命名空間的使用方式，例如?std::cin、std::cout、std::endl。

在日常練習中，可以使用?using namespace std;?來避免每次都寫?std::?前綴，使代碼更簡潔。

但在實際項目開發中不建議使用?using namespace std;，因為這樣可能會引起命名沖突，影響代碼的健壯性和可維護性。

4.7?與 <stdio.h> 的關系

在代碼中未包含?<stdio.h>?時，仍可使用?printf?和?scanf。

因為包含?<iostream>?時，某些編譯器（如 vs 系列編譯器）會間接包含?<stdio.h>，但其他編譯器可能會報錯，所以在不同編譯器環境下要注意這一情況。

一下則是針對cpp的輸入輸出的一段代碼：

#include <iostream>
using namespace std;int main()
{int a = 1;int b = 2;char c = a;cin >> a >> b >> c;cout << a <<" " <<b<<  " "<< c;	return 0;
}

運行效果：

5. 缺省參數

5.1 缺省參數的定義

缺省參數是在聲明或定義函數時為函數的參數指定的一個缺省值。當調用該函數時，如果調用時沒有為該參數指定實參，函數會采用該形參的缺省值；如果調用時指定了實參，函數則使用指定的實參。它也被稱為默認參數。

5.2 缺省參數的類別

全缺省參數：將函數的全部形參都指定缺省值

void func(int a = 1, int b = 2, int c = 3) {//函數體
}

在調用?func?函數時，可以不傳遞任何參數，此時?a?將為 1，b?將為 2，c?將為 3；

也可以傳遞部分或全部參數，如:

?func(4)?會使?a?為 4，b和c為原始缺省值，

func(4, 5)?會使?a?為 4，b?為 5，c?為原始缺省值。

半缺省參數：僅對部分形參指定缺省值。并且，C++ 規定半缺省參數必須從右往左依次連續缺省，不能間隔跳躍給缺省值。例如：
```
void func(int a, int b, int c = 3) {// 函數體
}
```
或者

void func(int a, int b = 2, int c = 3) {// 函數體
}

這是合法的，而像?void func(int a = 1, int b, int c = 3) { }?這樣的聲明是不合法的，因為缺省參數沒有從右向左連續設置。

5.3?帶缺省參數的函數調用規則：

當調用帶缺省參數的函數時，必須從左到右依次給實參，不能跳躍給實參。例如：

對于?void func(int a = 1, int b = 2, int c = 3);?這樣的函數聲明，如果調用?func(, 5, )?這樣的方式是錯誤的，而可以調用?func(4)、func(4, 5)?或?func(4, 5, 6)?等。

5.4?函數聲明和定義分離時的缺省參數設置：

當函數的聲明和定義分開時，缺省參數不能在函數聲明和定義中同時出現，因此一般都是在函數聲明中給出缺省值。例如：

// 函數聲明
void func(int a = 1, int b = 2, int c = 3);// 函數定義
void func(int a, int b, int c) {// 函數體
}

6. 函數重載

和c語言不同，C++?持在同?作?域中出現同名函數，但是要求這些同名函數的形參的個數或者是類型不同。

比如：

參數類型不同

int Add(int left, int right){cout << "int Add(int left, int right)" << endl;return left + right;}double Add(double left, double right){cout << "double Add(double left, double right)" << endl;return left + right;}int main()
{Add(10, 20);Add(10.1, 20.2);return 0;
}

參數個數不同

void f(){cout << "f()" << endl;}void f(int a){cout << "f(int a)" << endl;}int main()
{f();f(10);return 0;
}

參數類型的順序不同

void f(int a, char b){cout << "f(int a,char b)" << endl;}void f(char b, int a){cout << "f(char b, int a)" << endl;}int main()
{f(10, 'a');f('a', 10);return 0;
}

注意：

返回值不同無法作為函數重載的條件，因為在調用的時候也無法區分

void f()
{}int f(){     return 0;}

另外，下面兩個函數也構成重載，但是在對 f ( ) 調用的時編譯器會因為不知道調用誰而報錯

void f1(){cout<<"f()"<<endl;}void f1(int a = 10){cout<<"f(int a)"<<endl;}

7. 引用

7.1 引用的概念域定義

引用就是給已經存在的變量取一個別名，編譯器不會為引用變量開辟新的內存空間而是與被引用變量共用同一塊空間。

格式為：類型& 引用名 = 被引用對象；

 #include<iostream>using namespace std;int main(){int a = 0;// 引?：b和c是a的別名int& b = a;int& c = a;//也可以給別名b取別名，d相當于還是a的別名int& d = b;++d;//這?取地址我們看到是?樣的cout << &a << endl;cout << &b << endl;cout << &c << endl;cout << &d << endl;return 0;}

7.2 引用的特性

a. 引用在定義的時候必須初始化：

單打一個int&a系統會報錯，必須在后面跟上比如int& a=b;

b. 一個變量可以有多個引用：

比如上面說到的b和c都可以是a的引用變量

c. 引用一旦引用一個實體后便不可再引用其他的實體：

比方說b已經為a的引用變量，那么b就不能再為c的引用變量

7.3 引用的使用

7.3.1 引用傳參

 void Swap(int& rx, int& ry){int tmp = rx;rx = ry;ry = tmp;}int main(){int x = 0, y = 1;cout << x <<" " << y << endl;Swap(x, y);cout << x << " " << y << endl;return 0;}

在引用傳參時，它能夠減少拷貝，從而顯著提高程序運行效率，并且當在函數內部改變引用對象時，被引用對象也會同步改變。這一特性與指針傳參的功能類似，但引用傳參在使用上更為便捷，無需像指針那樣頻繁地進行解引用操作。

7.3.2 引用用作返回值

不過這種場景相對復雜。在這里，我們僅對基本場景做簡要介紹，后續在類和對象相關章節中，還會對其進行更深入的探討。

#include <iostream>
using namespace std;// 函數，使用引用作為返回值
int& returnRef(int& num) {num += 10;return num;
}int main() {int number = 5;cout << "Original value: " << number << endl;// 調用函數并將結果存儲在引用變量中int& resultRef = returnRef(number);cout << "Value after modification: " << resultRef << endl;// 再次調用函數修改原變量returnRef(resultRef);cout << "Value after second modification: " << number << endl;return 0;
}

我們還可以直接對returnRef（）進行“++”或者“--”操作，此時雖然是對函數名進行操作，但效果是直接作用在返回值上的。

7.4 const引用

7.4.1?引用const對象的規則

可以引用一個const對象，但必須使用const引用。同時，const引用也能夠引用普通對象。這是因為在引用過程中，對象的訪問權限可以縮小或平移，但不能放大。

權限放大：

const int a=10;

int& b=a;

權限平移：

const int a=10；

const int& b=a;

權限縮小：

int a=10;

const int& b=a;

看完這幾個你應該就能大致理解權限的幾種情況有所了解了。

事實上，這個const就像是一種限定條件，引用變量與被引用變量都有才為權限平移；

被引用變量有引用變量沒有，引用變量就變得無拘無束了，此時構成權限放大；

相反則是權限縮小。

7.4.2 臨時對象的定義

所謂臨時對象，是指當編譯器需要一個空間來暫存表達式的求值結果時，臨時創建的一個未命名的對象。在 C++ 中，這個未命名的對象就被稱為臨時對象。

7.4.3?臨時對象與權限放大問題

注意一些特殊場景：

int& rb = a * 3;，在這里，a * 3的計算結果會保存在一個臨時對象中，此時rb試圖引用這個臨時對象。
double d = 12.34; int& rd = d;，在這個類型轉換過程中，也會產生臨時對象來存儲中間值，rd引用的就是這個臨時對象。

由于 C++ 規定臨時對象具有常性，也就是具有只讀屬性。上述rb和rd的情況，相當于將一個具有只讀屬性（常性）的臨時對象通過普通引用（可讀寫）去引用，這就觸發了權限放大。所以，在這種情況下，必須使用常引用才可以。

因此上面兩種情況應該改為：

const?int& rb = a * 3;

double d = 12.34; const int& rd = d;

7.5 指針與引用的關系

7.5.1 語法概念層面

引用：本質上是為變量取別名，在內存中并不額外開辟新空間。

例如，若有int a = 5; int& ref = a;，這里的ref就是a的別名，二者共享同一塊內存空間。

指針：用于存儲變量的地址，因此需要開辟空間來存放該地址值。

如int a = 5; int* ptr = &a;，ptr變量存儲的是a的地址。

7.5.2 初始化要求

引用：在定義時必須進行初始化，否則會引發編譯錯誤。這是因為引用一旦定義，就必須與某個已存在的對象相關聯。

例如int& ref;（錯誤，未初始化），而int a = 5; int& ref = a;（正確）。

指針：雖然建議在定義時初始化，但從語法規則來講并非強制要求。不過，未初始化的指針在后續使用中極易引發難以排查的錯誤。

例如int* ptr;（合法但不推薦），int a = 5; int* ptr = &a;（推薦做法）。

7.5.3?指向對象的可變性

引用：一旦在初始化時引用了某個對象，就無法再引用其他對象。它與初始化時綁定的對象始終保持關聯。

例如int a = 5, b = 10; int& ref = a; ref = b;（這里ref = b;并非讓ref重新引用b，而是將b的值賦給ref所引用的a，a就變成10了）。

指針：具有靈活性，可以隨時改變指向的對象。

例如int a = 5, b = 10; int* ptr = &a; ptr = &b;，此時ptr從指向a變為指向b。

7.5.4 訪問指向對象的方式

引用：可以直接訪問所指向的對象，無需額外操作。

例如int a = 5; int& ref = a; int value = ref;，這里直接通過ref獲取到a的值。

指針：需要通過解引用操作符*來訪問其所指向的對象。

例如int a = 5; int* ptr = &a; int value = *ptr;，使用*ptr來獲取ptr所指向的a的值。

7.5.5?在sizeof操作中的含義

引用：sizeof引用的結果是引用類型本身的大小。例如int a = 5; int& ref = a; size_t size = sizeof(ref);，在 32 位和 64 位平臺下，size的值都為int類型的大小，通常為 4 字節（假設int為 4 字節）。
指針：sizeof指針的結果始終是地址空間所占的字節個數。在 32 位平臺下，指針占 4 個字節；在 64 位平臺下，指針占 8 個字節。例如int* ptr; size_t size = sizeof(ptr);，在不同平臺下，size的值如上述所述。

7.5.6 安全性考量

指針：由于其靈活性，很容易出現空指針（指向NULL的指針）和野指針（指向未定義或已釋放內存的指針）問題。

例如int* ptr = NULL; *ptr = 5;（空指針解引用，會導致程序崩潰），或者int* ptr = new int(5); delete ptr; *ptr = 10;（野指針訪問，同樣會引發未定義行為）。

引用：由于在定義時必須初始化且不能重新綁定到其他對象，所以很少出現類似指針的安全問題，使用起來相對更為安全

8. inline

8.1 內聯函數概述

用?inline?修飾的函數叫做內聯函數。編譯時，C++ 編譯器會在調用內聯函數的地方展開該函數，如此一來，調用內聯函數便無需建立棧幀，進而提高程序運行效率

通過調試時的匯編代碼能夠很清晰地看到這一點：

先是沒有inline的：

代碼

主函數匯編代碼

add函數匯編代碼

因此無inline的整體呈現應該為

再看看有inline的：

代碼

主函數匯編代碼

不難發現，有用inline關鍵字的在主函數調用該內聯函數時函數的確是直接展開的而不是像無inline的那樣還需要再創建函數棧幀。

8.2 編譯器對inline的處理

inline?對于編譯器而言只是一個建議，即便添加了?inline?關鍵字，編譯器也可選擇不在調用處展開。不同編譯器對于?inline?在何種情況下展開的規定各不相同，這是因為 C++ 標準并未對此作出明確規定。

通常，inline?適用于頻繁調用的短小函數，對于遞歸函數以及代碼相對較多的函數，即便加上?inline，也會被編譯器忽略.

8.3?與 C 語言宏函數的對比

在 C 語言中，宏函數會在預處理時進行替換展開。然而，宏函數的實現較為復雜，容易出錯，且不方便調試。

C++ 設計?inline?的目的便是為了替代 C 的宏函數，內聯函數在使用上更接近普通函數，會進行類型安全檢查等，其調試信息也比宏函數更有用.

8.4?VS 編譯器中 debug 版本的 inline 設置

在 VS 編譯器的 debug 版本下，默認是不展開?inline?的，這樣有利于調試。

若想在 debug 版本中展開?inline，需要進行以下兩處設置：

第一步，右鍵單擊項目，選擇屬性，找到 C/C++ 中的常規，將調試信息格式更改為程序數據庫；第二步，在優化中，將內聯函數擴展更改為只適用于?_inline(/Ob1).

8.5?inline 函數聲明和定義的注意事項

inline?不建議聲明和定義分離到兩個文件。因為?inline?函數被展開后就沒有函數地址，若聲明和定義分離，鏈接時會找不到函數地址，從而導致鏈接錯誤.

9. nullptr

9.1 NULL存在的問題

NULL實際上是一個宏概念，我們先來看一下在傳統的C頭?件(stddef.h)中可以看到的如下代碼：

#ifndef NULL #ifdef __cplusplus#define NULL 0#else#define NULL ((void *)0)#endif
#endif

#ifndef NULL：是一個條件編譯指令，檢查?NULL?是否已被定義。如果?NULL?未被定義，則執行后續代碼。

#ifdef __cplusplus：是另一個條件編譯指令，檢查當前是否在 C++ 環境下編譯（__cplusplus?是 C++ 編譯器會自動定義的宏）。

#define NULL 0：如果是在 C++ 環境下編譯，將?NULL?定義為 0。在 C++ 中，NULL?通常被定義為 0，因為 C++ 有更嚴格的類型檢查，并且可以將 0 隱式轉換為指針類型，而且 C++ 有?nullptr?關鍵字作為空指針常量，所以將?NULL?簡單地定義為 0 是可行的，這樣在使用時可以保證代碼的安全性和一致性。

#else：如果不在 C++ 環境下編譯（即假設是在 C 環境下）。

#define NULL ((void *)0)：將?NULL?定義為?(void *)0，這是 C 語言中傳統的空指針表示方法。將?NULL?定義為?(void *)0?是為了確保?NULL?可以被賦給任何指針類型，同時明確表示它是一個空指針，而不是一個普通的整數值。

這就會導致一些問題，比如：

#include<iostream>
using namespace std;void f(int x)
{cout << "f(int x)" << endl;
}void f(int* ptr)
{cout << "f(int* ptr)" << endl;
}int main()
{f(0);// 本想通過f(NULL)調?指針版本的f(int*)函數，但是由于NULL被定義成0，調?了f(int 
x)，因此與程序的初衷相悖。f(NULL);f((int*)NULL);
// 編譯報錯：error C2665: “f”: 2 個重載中沒有?個可以轉換所有參數類型// f((void*)NULL);f(nullptr);return 0;
}

本想通過f(NULL)調?指針版本的f(int*)函數，但是由于NULL被定義成0，調?了f(int?x)，因此與程序的初衷相悖。

f((int*)NULL一句會編譯報錯：error C2665: “f”: 2 個重載中沒有?個可以轉換所有參數類型
?因為NULL本來是（void*）NULL，?f((void*)NULL)相當于把（void*）隱式轉換為（int*）了，但因為 C++ 對類型安全的要求更高，是絕對不允許這種轉換發生的。

9.2 nullptr的性質

因此在 C++11 中，引入了一個重要的關鍵字?nullptr

nullptr?具有以下特殊性質：

它是一種特殊類型的字面量。
其特殊之處在于它能夠被隱式地轉換為任意其他類型的指針類型，這為指針操作提供了很大的便利。

9.3 nullptr的優勢

使用?nullptr?來定義空指針時，具有明顯的優勢：

避免了類型轉換問題：在使用傳統的?NULL?表示空指針時，由于?NULL?可能被定為?0?或?(void*)0，在某些情況下可能會導致類型轉換的混淆。例如，當試圖調用指針版本的函數時，可能因?NULL?被視為整數而調用錯誤的函數重載。
類型安全：nullptr?只能被隱式地轉換為指針類型，而不能被轉換為整數類型，這保證了類型的安全性。它確保了在代碼中，當使用?nullptr?時，編譯器會將其正確地識別為表示指針為空的情況，而不會被錯誤地當成整數來處理，從而避免了因類型轉換不清晰而引發的各種潛在錯誤，使得代碼更加清晰、健壯和易于維護。

通過使用?nullptr，C++ 程序員可以更安全、更準確地處理空指針的表示和操作，避免了使用傳統?NULL?表示空指針時可能帶來的一系列問題，提高了代碼的可靠性和可維護性。

那么以上便是本次C++前期學習的一些基礎知識分享了

如果你能夠從這篇文章中得到一些啟發的話麻煩你給我個一鍵三連，這將會給我莫大的鼓舞~

十分感謝你能夠看到這里！

那么我們下次再見~