資訊專欄INFORMATION COLUMN
摘要：使用命名空間的目的是對標識符的名稱進行本地化，以避免命名沖突或名字污染，關鍵字的出現就是針對這種問題的。缺省參數概念缺省參數是聲明或定義函數時為函數的參數指定一個默認值。
在C/C++中，變量、函數和后面要學到的類都是大量存在的，這些變量、函數和類的名稱將都存在于全局作
用域中，可能會導致很多沖突。使用命名空間的目的是對標識符的名稱進行本地化，以避免命名沖突或名字
污染，namespace關鍵字的出現就是針對這種問題的。
定義命名空間，需要使用到namespace關鍵字，后面跟命名空間的名字，然后接一對{}即可，{}中即為命名
空間的成員。
//1. 普通的命名空間namespace N1 // N1為命名空間的名稱{// 命名空間中的內容，既可以定義變量，也可以定義函數int a;int Add(int left, int right){ return left + right;}}//2. 命名空間可以嵌套namespace N2{int a;int b;int Add(int left, int right){ return left + right;}namespace N3{int c;int d;int Sub(int left, int right){ return left - right;}}}//3. 同一個工程中允許存在多個相同名稱的命名空間,編譯器最后會合成同一個命名空間中。namespace N1{int Mul(int left, int right){ return left * right;}}注意：一個命名空間就定義了一個新的作用域，命名空間中的所有內容都局限于該命名空間中
命名空間中成員該如何使用呢？比如：
namespace N{int a = 10;int b = 20;int Add(int left, int right){return left + right;}int Sub(int left, int right){return left - right;}}int main(){//錯誤寫法printf("%d/n", a); // 該語句編譯出錯，無法識別a //正確寫法printf("%d/n", N::a);//需要說明a是屬于命名空間N中的return 0;}命名空間使用{}括起來的，不用加分號。
命名空間的使用有三種方式：
使用using namespace 命名空間名稱引入
優點：用起來方便
缺點：把自己的定義暴露出去了，導致命名污染
using namespce N;//展開命名空間N，可以不加限定地使用N中的內容int main(){printf("%d/n", N::a);printf("%d/n", b);Add(10, 20);return 0;}加命名空間名稱及作用域限定符
優點：不存在命名污染
缺點：用起來麻煩，每個都得去制定命名空間
int main(){ printf("%d/n", N::a);//a屬于命名空間N return 0;} using N::b;//將命名空間N中的b展開，類似全局變量一樣使用int main(){ printf("%d/n", N::a); printf("%d/n", b); return 0;}C++的輸出：
#includeusing namespace std;int main(){ cout<<"Hello world!!!"< 說明：
使用cout標準輸出(控制臺)和cin標準輸入(鍵盤)時，必須包含< iostream >頭文件以及std標準命名空
間。
類似C中的
注意：早期標準庫將所有功能在全局域中實現，聲明在.h后綴的頭文件中，使用時只需包含對應頭文件
即可，后來將其實現在std命名空間下，為了和C頭文件區分，也為了正確使用命名空間，規定C++頭文
件不帶.h；舊編譯器(vc 6.0)中還支持
+std的方式。
cout需要與<<配合使用，<<就像箭頭一樣指向cout，說明流向cout流入。
而cin需要與>>配合使用，>>說明向數據流入，也就是輸入。
使用C++輸入輸出更方便，cout可以自動識別數據類型，不需增加數據格式控制，比如：整形–%d，字符–%c
C++中的換行方式。
#include using namespace std;int main(){ int a; double b; char c; cin>>a;//對a的值進行輸入 cin>>b>>c;//對b、c的值進行輸入 cout< 有一些場景更適合printf：
struct Student{ char*name; int age;};int main(){ struct Student s = {"zhangsan", 18}; cout << "名字：" << s.name << " " << "年齡：" << s.age << endl; printf("名字：%s 年齡:%d/n", s.name, s.age); //或者 double d = 1.1111111; printf("%.2f/n", d); //cout默認最多只輸出浮點數小數點后5位 cout << d << endl; }缺省參數就像備胎一樣，傳了實參它就不發揮作用，不穿實參他才發揮作用。
缺省參數是聲明或定義函數時為函數的參數指定一個默認值。在調用該函數時，如果沒有指定實參則采用該
默認值，否則使用指定的實參。
void TestFunc(int a = 0){ cout<全缺省參數
對所有參數都設置了備胎：
void TestFunc(int a = 10, int b = 20, int c = 30){ cout<<"a = "<void TestFunc(int a, int b = 10, int c = 20){ cout<<"a = "<void TestFunc(int a = 10, int b = 20, int c) 否則在傳參的時候， TestFunc(10, 20);不知道參數是給哪個形參的
沒有缺省必須要傳參。
比如我們定義了這樣一個缺省函數：
void TestFunc(int a, int b = 10, int c = 20){ cout<<"a = "<//a.hvoid TestFunc(int a = 10); // a.cvoid TestFunc(int a = 20){}// 注意：如果聲明與定義位置同時出現，恰巧兩個位置提供的值不同，那編譯器就無法確定到底該用那個缺省值。 ?
函數重載就是同一個函數名可以多次創建使用，但需要符合一定的條件。
函數重載:是函數的一種特殊情況，C++允許在同一作用域中聲明幾個功能類似的同名函數，這些同名函數的
形參列表(參數個數 或 類型 或 順序)必須不同，返回類型可以不同，但前面幾個一定要有一個或多個不同。常用來處理實現功能類似數據類型不同的問題。
int Add(int left, int right){ return left+right;}double Add(double left, double right){ return left+right;}long Add(long left, long right){ return left+right;}int main(){ Add(10, 20); Add(10.0, 20.0); Add(10L, 20L); return 0;}下面兩個函數屬于函數重載嗎？
short Add(short left, short right){ return left+right;}int Add(short left, short right){ return left+right;}答案是：不屬于。
雖然返回類型不同，但形參的類型，順序，個數都是相同的，所以這兩個函數不屬于函數重載。
為什么C++支持函數重載，而C語言不支持函數重載呢？
在C/C++中，一個程序要運行起來，需要經歷以下幾個階段：預處理、編譯、匯編、鏈接。
采用C語言編譯器編譯后結果
可以看到C語言編譯后生成的函數名字與原名相同，其實是生成的符號表中，Add、func的名稱就是原名。
采用C++編譯器編譯后結果
而C++經過編譯后，生成的符號表中對應Add、func的名稱是經過修飾的，所以支持重載函數。
結論：在linux下，采用g++編譯完成后，函數名字的修飾發生改變，編譯器將函數參數類型信息添加到修改后的名字中
通過這里就理解了C語言沒辦法支持重載，因為同名函數沒辦法區分。而C++是通過函數修飾規則來區
分，只要參數不同，修飾出來的名字就不一樣，就支持了重載。
函數名相同、參數類型、順序相同，返回類型不同可以構成重載嗎？
不能，如果把返回值帶進修飾規則，那么編譯器層面是可以區分的。但是語法調用層面，很難區分，帶有嚴重的歧義。
比如無參函數fun()，如果一個返回值是int，一個是double，這如何區分呢。
下面兩個函數能形成函數重載嗎？有問題嗎或者什么情況下會出問題？
void TestFunc(int a = 10){ cout<<"void TestFunc(int)"<不能形成函數重載，函數的形參個數、類型、順序都相同，不符合重載函數的必備條件
C語言中為什么不能支持函數重載？
C語言編譯時生成的符號表中，函數的名字就是原名，沒有修飾，因此只能一個函數名只能對應一個函數。
C++中函數重載底層是怎么處理的？
C++與C語言不同，C++編譯時生成的符號表中，函數名稱是經過修飾的，修飾包括函數的參數類型、順序，所以對相同地函數名，如果形參的順序、個數、類型不同，就可以實現重載函數。
C++中能否將一個函數按照C的風格來編譯？
能，因為C++是支持C的語法的。
有時候在C++工程中可能需要將某些函數按照C的風格來編譯，在函數前加extern “C”，意思是告訴編譯器，將該函數按照C語言規則來編譯。比如：tcmalloc是google用C++實現的一個項目，他提供tcmallc()和tcfree兩個接口來使用，但如果是C項目就沒辦法使用，那么就需要使用extern “C”來解決。
C語言實現的模塊是放在靜態庫或者動態庫里的，因此編譯時引用里面的模塊，名稱是不能直接識別的，而C++是兼容C的，想要C++也使用該模塊，就要使用extern “C”。
使用格式：
例如：extern “C” int Add(int left, int right)
關于extern "C"的更多內容，可以百度答案：[extern “C”_百度百科 (baidu.com)](https://baike.baidu.com/item/extern “C”/15267013)
引用就像給變量取別名，不會重新開辟空間，只是使變量多了一個名稱。
類型& 引用變量名(對象名) = 引用實體
void TestRef(){ int a = 10; int& ra = a;//<====定義引用類型 printf("%p/n", &a); printf("%p/n", &ra);}注意：引用類型必須和引用實體是同種類型的
void TestRef(){ int a = 10; // int& ra; // 該條語句編譯時會出錯 int& ra = a; int& rra = a; printf("%p %p %p/n", &a, &ra, &rra);}這一段代碼是將b的值賦給c，還是使c變成b的引用？
int a = 1; int&c = a; int b = 2; c = b;根據上面的特性3，c = b是將b的值賦給c，而不是使c再變成b的引用。
指針的引用：
int main(){ int x = 10; int y = 20; int* p1 = &x; int* p2 = &y; int*& p3 = p1;//p3是p1的別名 *p3 = 20;//x的值被改為20 p3 = p2;//p1、p3改變指向，指向了y return 0;}*p3 = 20前：
x = 10
*p3 = 20后：
x = 20
p3 = p2前：
p1、p3指向x，p2指向y
p3 = p2后：
p1、p3都指向了y
常引用類似C語言中指針加const。
void TestConstRef(){ const int a = 10; //int& ra = a; // 該語句編譯時會出錯，a為常量，這么做是權限的放大 const int& ra = a;//正確引用 // int& b = 10; // 該語句編譯時會出錯，b為常量，同樣是權限的放大 const int& b = 10;//正確引用 double d = 12.34; //int& rd = d; // 該語句編譯時會出錯，類型不同，經轉換后沒有修改內存中的內容的權力 const int& rd = d;}指針中：
1. int a = 10; const int*cp1 = &a; int *p1 = cp1;//不行，因為cp1指向的內容都是不可以修改的，p1這個例子是權限的放大2. int a = 10; int *p1 = &a; const int*cp1 = p;//可以，p1指向的內容是可以修改的，cp1是權限的縮小，沒問題。我們分析一下最后一個例子：
double d = 12.34; //int& rd = d; // 該語句編譯時會出錯，類型不同 const int& rd = d;為什么加上const后就可以了呢？
我們先看這段代碼：
double d = 12.34; int a = d;這段代碼會發生一個隱式類型轉換，而隱式類型轉換實際上是產生一個int類型的臨時變量，該變量是常變量。再將常變量的值賦給a，a的內存是新開辟的內存。而如果是引用：const int& rd = d;就必須要加上const修飾，被轉換之后，該值只能被讀取而不能修改，因為rd使用的是臨時變量的內存，臨時變量具有常屬性，是不能修改的。
總結：引用取別名時，變量訪問的權限可以縮小，不能放大。
做參數
void Swap(int& left, int& right){ int temp = left; left = right; right = temp;}left和right是實參的別名，不同于指針，在Swap里修改了left和right就是修改了實參
作用：
做返回值
int Count1(){ static int n = 0； n++; // ... return n;}int& Count2(){ static int n = 0； n++; // ... return n;}int main(){ int& r1 = Count1();//不可以，Count1返回值是一個常變量 int& r2 = Count2();//可以，Count2的返回值是n的別名}返回值返回的是臨時變量（具有常屬性）
Count1：會開辟一塊空間給tmp：int tmp = n，tmp是常變量，不可被修改，所以用const
Count2：int& tmp = n，tmp是n的別名，但實際上這么寫是內存的非法訪問，n的內存實際上以及不能再使用了，但那塊內存的值還存在
r1不行，r2可以
作用：少創建一個臨時拷貝對象，提高效率
而當代碼變為下面這樣時，使用引用返回就不安全，因為c不再是靜態變量，而是一個局部變量，當Add返回時，Add函數的空間已經返回給操作系統了，那塊系統還在，只是使用權已經不是我們的了。
int& Add(int a, int b){ int c = a + b; return c;}int main(){ int& ret = Add(1, 2); Add(3, 4); cout << "Add(1, 2) is :"<< ret <一個函數要使用引用返回，返回變量出了這個函數的作用域還存在，就可以使用引用返回，否則就不安全，就必須使用傳值返回
以值作為參數或者返回值類型，在傳參和返回期間，函數不會直接傳遞實參或者將變量本身直接返回，而是
傳遞實參或者返回變量的一份臨時的拷貝，因此用值作為參數或者返回值類型，效率是非常低下的，尤其是
當參數或者返回值類型非常大時，效率就更低。
#include struct 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 < 100000; ++i) TestFunc1(a); size_t end1 = clock(); // 以引用作為函數參數 size_t begin2 = clock(); for (size_t i = 0; i < 100000; ++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;} 測評效果：
由此可知，以引用做參數的效率比傳值做參數的效率快了，省去了參數拷貝的時間開銷
#include struct 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<int main(){ int a = 10; int& ra = a; ra = 20; int* pa = &a; *pa = 20; return 0;} 我們來看下引用和指針的匯編代碼對比：
可以觀察到實際上b和p在匯編時執行的內容是一樣的，只不過我們在語法理解時，是b沒有開辟新空間，只是a的一個別名，而指針p是開辟了空間保存a的地址的。
引用和指針的不同點:
文章版權歸作者所有，未經允許請勿轉載,若此文章存在違規行為，您可以聯系管理員刪除。
轉載請注明本文地址：http://m.specialneedsforspecialkids.com/yun/121540.html
摘要：更多文章請前往我的個人博客這個問題是有關執行順序和的。其中，整體代碼，可以理解為待執行的所有代碼。當隊列執行完后再執行一個任務。然后再次回到新的事件循環。所以兩個執行完后隊列里只剩下第一個里的。 『前端碎碎念』系列會記錄我平時看書或者看文章遇到的問題，一般都是比較基礎但是容易遺忘的知識點，你也可能會在面試中碰到。 我會查閱一些資料并可能加上自己的理解，來記錄這些問題。更多文章請前往我...
摘要：判斷步驟如下如果有一個操作數是布爾值，則在比較相等性之前先將其轉換為數值轉換為，而轉換為。實際上是對比運用上面的順序，是布爾值，所以轉化為數值為。 『前端碎碎念』系列會記錄我平時看書或者看文章遇到的問題，一般都是比較基礎但是容易遺忘的知識點，你也可能會在面試中碰到。 我會查閱一些資料并可能加上自己的理解，來記錄這些問題。更多文章請前往我的個人博客 類似標題中的問題還有很多，例如： 為...
摘要：前端碎碎念系列會記錄我平時看書或者看文章遇到的問題，一般都是比較基礎但是容易遺忘的知識點，你也可能會在面試中碰到。當兩個操作數都是數值時，執行常規的數值加法計算。關鍵還是要加深對中對數值轉換的理解，以不變應萬變。 『前端碎碎念』系列會記錄我平時看書或者看文章遇到的問題，一般都是比較基礎但是容易遺忘的知識點，你也可能會在面試中碰到。 我會查閱一些資料并可能加上自己的理解，來記錄這些問題...
摘要：本文旨在澄清里和的概念。的創建并返回的這個實例，是裸的。然后我們的的再接手這個裸的實例去進一步加工，比如加上各種，或再執行一些別的這個過程就是。如果用了，那么就可以無視這個，因為就可以理解成一個普通的函數表示這個類本身。 本文旨在澄清 python 里 __new__ vs __init__ 和 cls vs self 的概念。 很多初學者會困擾，python的魔法函數 __new_...
閱讀 1860·2021-09-29 09:35
閱讀 2721·2021-09-22 15:25
閱讀 1978·2021-08-23 09:43
閱讀 2056·2019-08-30 15:54
閱讀 3357·2019-08-30 15:53
閱讀 2394·2019-08-30 13:50
閱讀 2406·2019-08-30 11:24
閱讀 2277·2019-08-29 15:37
