c++介紹與入門基礎（詳細總結）-創新互聯

以值作為參數或者返回值類型，在傳參和返回期間，函數不會直接傳遞實參或者將變量本身直接返回，而是傳遞實參或者返回變量的一份臨時的拷貝，因此用值作為參數或者返回值類型，效率是非常低下的，尤其是當參數或者返回值類型非常大時，效率就更低。

#includestruct A{ 
	int a[10000];
};
void TestFunc1(A a){
}

void TestFunc2(A& a){
}

void TestRefAndValue(){
	A a;    // 以值作為函數參數    
	size_t begin1 = clock();  
	for (size_t i = 0; i< 10000; ++i)  
		TestFunc1(a);   
	size_t end1 = clock();
	// 以引用作為函數參數   
	size_t begin2 = clock();
	for (size_t i = 0; i< 10000; ++i)    
		TestFunc2(a); 
	size_t end2 = clock();
	// 分別計算兩個函數運行結束后的時間  
	cout<< "TestFunc1(A)-time:"<< end1 - begin1<< endl;  
	cout<< "TestFunc2(A&)-time:"<< end2 - begin2<< endl;
}

int main()
{
	TestRefAndValue();

	return 0;
}

傳值和指針在作為傳參以及返回值類型上效率相差很大。

#includestruct A{ int a[10000]; };

A a;// 值返回
A TestFunc1() {
	return a;
}
// 引用返回
A& TestFunc2(){
	return a;
}
void TestReturnByRefOrValue(){  
	// 以值作為函數的返回值類型    
	size_t begin1 = clock();    
	for (size_t i = 0; i< 100000; ++i)      
		TestFunc1();  
	size_t end1 = clock();
	// 以引用作為函數的返回值類型   
	size_t begin2 = clock();  
	for (size_t i = 0; i< 100000; ++i) 
		TestFunc2();   
	size_t end2 = clock();
	// 計算兩個函數運算完成之后的時間   
	cout<< "TestFunc1 time:"<< end1 - begin1<< endl;  
	cout<< "TestFunc2 time:"<< end2 - begin2<< endl;
}

int main()
{
	TestReturnByRefOrValue();

	return 0;
}

在語法概念上引用就是一個別名，沒有獨立空間，和其引用實體共用同一塊空間。

int main(){
	int a = 10; 
	int& ra = a;
	cout<< "&a = "<< &a<< endl; 
	cout<< "&ra = "<< &ra<< endl;
	return 0;
}

在語法上，他們的地址都是一樣的，所以共用一塊空間。但是在底層實現上實際是有空間的，因為引用是按照指針方式來實現的。

int main(){
	int a = 10;
	int& ra = a; 
	ra = 20;
	int* pa = &a;
	*pa = 20;
	return 0;
}

引用和指針的語法對比圖：

我們來看下引用和指針的匯編代碼對比：

在底層引用與指針，當變量很小的時候都是用寄存器存儲的，相當于開辟一塊臨時變量。?

引用和指針的不同點:

1. 引用概念上定義一個變量的別名，指針存儲一個變量地址。

2. 引用在定義時必須初始化，指針沒有要求

3. 引用在初始化時引用一個實體后，就不能再引用其他實體，而指針可以在任何時候指向任何一個同類型實體

4. 沒有NULL引用，但有NULL指針

5. 在sizeof中含義不同：引用結果為引用類型的大小，但指針始終是地址空間所占字節個數(32

位平臺下占4個字節)

6. 引用自加即引用的實體增加1，指針自加即指針向后偏移一個類型的大小

7. 有多級指針，但是沒有多級引用

8. 訪問實體方式不同，指針需要顯式解引用，引用編譯器自己處理

9. 引用比指針使用起來相對更安全

? 在c語言中，我們為了解決調用函數不開辟棧幀，我們經常會使用到宏，但是使用宏是有缺陷的，1不能調試，2沒有類型安全檢查，3容易寫錯。為了解決這些問題c++就使用內聯函數。

#include#define Add(x,y) ((x)+(y))

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

int main()
{
	int x = 10, y = 20;
	int ret = Add(x, y);
	int ret2 = add(x, y);

	printf("%d\n",ret);
	printf("%d\n", ret2);

	return 0;
}

以inline修飾的函數叫做內聯函數，編譯時C++編譯器會在調用內聯函數的地方展開，沒有函數調 用建立棧幀的開銷，內聯函數提升程序運行的效率。

如果在上述函數前增加inline關鍵字將其改成內聯函數，在編譯期間編譯器會用函數體替換函數的 調用。

查看方式：?

1. 在release模式下，查看編譯器生成的匯編代碼中是否存在call Add

2. 在debug模式下，需要對編譯器進行設置，否則不會展開(因為debug模式下，編譯器默認不 會對代碼進行優化，以下給出vs2013的設置方式)

1. inline是一種以空間換時間的做法，如果編譯器將函數當成內聯函數處理，在編譯階段，會 用函數體替換函數調用，缺陷：可能會使目標文件變大，優勢：少了調用開銷，提高程序運行效率。

展開會用更多的寄存器，空間就會變大，這樣就會影響可執行程序的大小--安裝包。

2. inline對于編譯器而言只是一個建議，不同編譯器關于inline實現機制可能不同，一般建議：將函數規模較小(即函數不是很長，具體沒有準確的說法，取決于編譯器內部實現)、不是遞歸、且頻繁調用的函數采用inline修飾，否則編譯器會忽略inline特性。

當函數長了之后展開會發聲代碼膨脹

3. inline不建議聲明和定義分離，分離會導致鏈接錯誤。因為inline被展開，就沒有函數地址 了，鏈接就會找不到。 ?

// F.h

#includeusing namespace std;

inline void f(int i);

// F.cpp

#include "F.h"

void f(int i)
{
 cout<< i<< endl;
}

// main.cpp

#include "F.h"

int main()
{
 f(10);
 return 0;
}

// 鏈接錯誤：main.obj : error LNK2019: 無法解析的外部符號 "void __cdecl 
f(int)" (?f@@YAXH@Z)，該符號在函數 _main 中被引用

隨著程序越來越復雜，程序中用到的類型也越來越復雜，經常體現在：

1. 類型難于拼寫

2. 含義不明確導致容易出錯

#include#include

std::map::iterator 是一個類型，但是該類型太長了，特別容 易寫錯。聰明的同學可能已經想到：可以通過typedef給類型取別名，比如： ?

#include #include

typedef std::mapstd::string, std::string>Map;

int main() {
 Map m{ 
           {
                 "apple", "蘋果" },{ "orange", "橙子" }, {"pear","梨"} 
};

使用typedef給類型取別名確實可以簡化代碼，但是typedef有會遇到新的難題： 在編程時，常常需要把表達式的值賦值給變量，這就要求在聲明變量的時候清楚地知道表達式的 類型。然而有時候要做到這點并非那么容易，因此C++11給auto賦予了新的含義。

在早期C/C++中auto的含義是：使用auto修飾的變量，是具有自動存儲器的局部變量，但遺憾的 是一直沒有人去使用它，大家可思考下為什么？

C++11中，標準委員會賦予了auto全新的含義即：auto不再是一個存儲類型指示符，而是作為一 個新的類型指示符來指示編譯器，auto聲明的變量必須由編譯器在編譯時期推導而得。

int TestAuto()
{
 return 10;
}

int main()
{
 int a = 10;
 auto b = a;
 auto c = 'a';
 auto d = TestAuto();
 
 cout<< typeid(b).name()<< endl;
 cout<< typeid(c).name()<< endl;
 cout<< typeid(d).name()<< endl;
 
 //auto e; 無法通過編譯，使用auto定義變量時必須對其進行初始化

 return 0;
}

【注意】

使用auto定義變量時必須對其進行初始化，在編譯階段編譯器需要根據初始化表達式來推導auto的實際類型。因此auto并非是一種“類型”的聲明，而是一個類型聲明時的“占位符”，編譯器在編 譯期會將auto替換為變量實際的類型。

1. auto與指針和引用結合起來使用 用auto聲明指針類型時，用auto和auto*沒有任何區別，但用auto聲明引用類型時則必須 加&

int main()
{
 ? ?int x = 10;
 ? ?auto a = &x;
 ? ?auto* b = &x;
 ? ?auto& c = x;
 ? ?cout<< typeid(a).name()<< endl;
 ? ?cout<< typeid(b).name()<< endl;
 ? ?cout<< typeid(c).name()<< endl;
 ? ?*a = 20;
 ? ?*b = 30;
 ? ? c = 40;
 ? ?return 0;
}

2. 在同一行定義多個變量 當在同一行聲明多個變量時，這些變量必須是相同的類型，否則編譯器將會報錯，因為編譯 器實際只對第一個類型進行推導，然后用推導出來的類型定義其他變量。 ??

void TestAuto()
{
 ? ?auto a = 1, b = 2; 
 ? ?auto c = 3, d = 4.0; ?// 該行代碼會編譯失敗，因為c和d的初始化表達式類型不同

}

1. auto不能作為函數的參數

// 此處代碼編譯失敗，auto不能作為形參類型，因為編譯器無法對a的實際類型進行推導

void TestAuto(auto a)
{}

2. auto不能直接用來聲明數組 ?

void TestAuto()
{
 ? ?int a[] = {1,2,3};
 ? ?auto b[] = {4，5，6};
}

3. 為了避免與C++98中的auto發生混淆，C++11只保留了auto作為類型指示符的用法

4. auto在實際中最常見的優勢用法就是跟以后會講到的C++11提供的新式for循環，還有

lambda表達式等進行配合使用。

在C++98中如果要遍歷一個數組，可以按照以下方式進行：

void TestFor()
{
 int array[] = { 1, 2, 3, 4, 5 };
 for (int i = 0; i< sizeof(array) / sizeof(array[0]); ++i)
 ? ? array[i] *= 2;
 
 for (int* p = array; p< array + sizeof(array)/ sizeof(array[0]); ++p)
 ? ? cout<< *p<< endl;
}

對于一個有范圍的集合而言，由程序員來說明循環的范圍是多余的，有時候還會容易犯錯誤。因 此C++11中引入了基于范圍的for循環。for循環后的括號由冒號“ ：”分為兩部分：第一部分是范 圍內用于迭代的變量，第二部分則表示被迭代的范圍。

void TestFor()
{
 int array[] = { 1, 2, 3, 4, 5 };
 for(auto& e : array)
 ? ? e *= 2;
 
 for(auto e : array)
 ? ? cout<< e<< " ";
 
 return 0;
}

注意：

與普通循環類似，可以用continue來結束本次循環，也可以用break來跳出整個循環。?

1. for循環迭代的范圍必須是確定的 對于數組而言，就是數組中第一個元素和最后一個元素的范圍；對于類而言，應該提供begin和end的方法，begin和end就是for循環迭代的范圍。

注意：以下代碼就有問題，因為for的范圍不確定

void TestFor(int array[])
{
 ? ?for(auto& e : array)
 ? ? ? ?cout<< e<

2. 迭代的對象要實現++和==的操作。(關于迭代器這個問題，以后會講，現在提一下，沒辦法 講清楚，現在大家了解一下就可以了)

void TestPtr()
{
 int* p1 = NULL;
 int* p2 = 0;
 
 // ……

}

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

void f(int)
{
 cout<<"f(int)"<