C++中需要注意的細節有哪些

這篇文章給大家介紹C++中需要注意的細節有哪些，內容非常詳細，感興趣的小伙伴們可以參考借鑒，希望對大家能有所幫助。

namespace的使用

#include <iostream>
using namespace std;
//定義命名空間
namespace NameSpaceA
{
    int a = 0;
}
namespace NameSpaceB
{
    int a=1;
    namespace NameSpaceC
    {
        struct Teacher
        {
            /* data */
            char name[10];
            int age;
        };
    }
}
int main()
{
    //using namespace NameSpaceA;
    using NameSpaceB::NameSpaceC::Teacher;
    using namespace NameSpaceB;
    printf("a = %d \n",a);
    printf("a = %d \n",NameSpaceA::a);
    Teacher t1;
    t1.age = 20;
    printf("age: %d \n",t1.age);
    return 0;
}

const使用：

//C++編譯器對const常量的處理
//當看見常量聲明時,會在符號表中放入常量-->當要使用時，直接取符號表中的值替換
//C中的const變量是個只讀變量,但自己的存儲空間
//C++中-->const為全局或&時才會分配空間
//#define和const相同之處：C++中的const修飾,是一個真正的常量，而C中只是個只讀變量。const修飾的常量在編譯期間就確定了。
//#define與const不同之處：#define-->由預處理器處理,單純的文本替換
//                       const---->編譯器處理,提供類型檢查和作用域檢查
#include <iostream>
using namespace std;
void fun1()
{
    #define a 10
    const int b = 20;
}
void fun2()
{
    printf("%d\n",a);
    //cout<<b<<endl;
}
int main()
{
    //int &a = 20;
    const int &b = 30;   //直接取符號表中的值代替,當使用&或者extern時會給常量分配內存空間
    fun1();
    fun2();
    getchar();
    return 0;
}

引用

//引用的本質：
//          1 引用在C++內部實現是一個常指針   Type &name --> Type * const name
//          2 C++編譯器在編譯過程中使用常指針作為引用的內部實現.因此所占用的空間與指針一樣大 4
//          3 C++為引用的使用做了細節隱藏
/*
    函數返回值是引用：
           1  難點注意：要觀察返回的變量是在哪里分配內存空間的--->如果是臨時變量，即在棧上分配內存,函數返回時會被析構(釋放)
                            --> 不能作為左值使用，因為空間被釋放了。沒地方存了
                            --> 不能成為其它引用的初始值,空間被釋放了
           2  c++鏈式編程編程、操作符重載
*/
/*
    指針的引用-->只不過是為存儲指針的這塊內存取了個別名而已
*/
#include <iostream>
using namespace std;
//證明引用有自己的內存空間
struct  Teacher
{
    /* data */
    int &a;
    int &b;
};
int main2()
{
    printf("sizeof(Teacher):%d \n",sizeof(Teacher));  //8-->int const *a and int const *b
    return 0;
}
int main1()
{
    int a   =  10;
    int &b  = a;
    printf("&a:%d\n",&a);
    printf("&b:%d\n",&b);  
    //對同一內存空間可以取好幾個名字嗎？    -->   不行
    //實際上：int const *b = &a     &b:編譯器會幫我們做 *(&b) 
    return 0;
}
//引用做函數返回值
int f1()
{
    int a;
    a = 10;
    return a;
}
int &f2()
{
    int a;
    a = 20;
    return a;
}
int *f3()
{
    int a;
    a = 30;
    return &a;
}
//---> 害，其實就一句話,看內存有沒有被釋放而已
//static + &引用
int j()             //-->返回的只是一個數值而已
{
    static int a = 10;
    a++;
    printf("a:%d \n",a);
    return a;
}
int &j2()           //返回 *(&a)
{
    static int a = 20;
    a++;
    printf("a:%d \n",a);
    return a;
}
int *j3()           //->返回的是一個地址
{
    static int a = 30;
    a++;
    printf("a:%d \n",a);
    return &a;
}
int main33()
{
    //j()-->返回的是一個數值,不能當左值  11 = 100(err)
    j2() = 100;
    j2();
    //手工打造引用條件
    *(j3()) = 100;
    j3();
    getchar();
    return 0;
}
//非基礎類型：可能設計到深拷貝和淺拷貝的問題-->其實也就是有沒有內存空間的問題
struct Student
{
    int  age;
};
Student & Op(Student &s)
{
    /* data */
    s.age = 30;
}
int main44()
{
    Student s1;
    s1.age = 20;
    Op(s1);
    cout<<s1.age;
    return 0;
}
//常引用-->const難點
int main55()
{
    int a = 10;
    const int &b = a;   //const char const* b = xxxx ---> 但a可以改變
   // b = 11;   
    a = 20;
    int *p = (int *)&b;
    //
    const int aa = 20;
    const int &bb = aa;
    //int &b = aa;
}
//const:常量 pk 變量 -->const int *const  p
int main()
{
    const int b =10;
    printf("&b:%d \n",&b);
    const int &bb = 19;
    printf("&bb:%d \n",&bb);
    getchar();
    return 0;
}

三目運算

//在C++中，三目運算返回變量本身，可以做左值
#include <iostream>
using namespace std;
int main()
{
    int a = 20;
    int b = 30;
    a = (a<b?a:b) = 30;
    cout<<a<<endl;
    getchar();
    return 0;
}

函數相關

#include <iostream>
using namespace std;
/*
    第一部分：inline函數
        1.內聯函數聲明時inline關鍵字必須和函數定義結合在一起,否則編譯器會直接忽略請求
        2.內聯函數是一種特殊的函數,具有普通函數的特征(參數檢查，返回類型等)
            -->相對于普通的函數而言,內聯函數省去了壓棧、跳轉、返回的開銷
        3.內聯函數由編譯器處理,然后將編譯后的函數體直接插入調用的地方
          宏定義-->預處理器處理,進行簡單的文本替換,沒有任何編譯過程
*/
#define  MYFUNC(a,b)    ((a)<(b)?(a):(b))   //預處理階段,簡單的文本替換
inline int func(int a , int b)      //經歷編譯過程
{
    return a<b?a:b;
}
int main01()
{
    int a = 1;
    int b = 3;
    int c =func(++a,b);
    cout<<c;    //2
    int d = MYFUNC(++a,b);
    cout<<d<<"  ";  //3
    getchar();
    return 0;
}
/*
    第二部分：函數的占位參數：
            占位參數只有參數類型聲明,而沒有參數名聲明
            一般情況下,函數內部無法使用占位參數
*/
int f(int a , int b , int)
{
    return a+b;
}
int main02()
{
    // int c = f(1,2);
    //cout<<c<<"  ";
    int d = f(1,2,3);
    cout<<d;
    getchar();
    return 0;
}
//默認參數和占位參數一起使用-->可以方便程序的擴展
int f2(int a,int b,int = 0)
{
    return a+b;
}
int main022()
{
    f2(1,2);
    f2(1,2,3);
    getchar();
    return 0;
}
/*
    第三部分:
        函數重載-->參數個數不同 、 參數類型不同 、 參數順序不同
        編譯器調用重載函數的準則：
                將所有同名函數作為候選者
                嘗試尋找可行的候選者
                精確匹配實參
        匹配失敗：
                找到的可行函數不唯一,出現二義性,編譯失敗
                沒有找到可行的函數
        注意事項：
                重載函數在本質上是不同的函數,是相互獨立的(靜態鏈編)
                函數重載是發生在同一個類里面的
*/
//函數重載遇上函數指針
int g(int x)
{
    return x;
}
int g(int a ,int b)
{
    return a+b;
}
typedef int(*PFUNC)(int);
int main()
{
    int c = 0;
    PFUNC p = g;
    c = p(1);
    cout<<c<<endl;
    getchar();
    return 0;
}
//register-->暗示編譯程序相應的變量將被頻繁的使用,如果可能的話,應該將其放到CPU的寄存器中,加快訪問速度
//減少了去內存中尋址、取值
// #ifdef NOSTRUTASSIGN
//     memcpy (d , s , l)
//     {
//         register char *d;
//         register char *s;
//         register int  l;
//         while (l--)
//         {
//             *d++ = *s++;
//         }
//     }
// #endif

關于C++中需要注意的細節有哪些就分享到這里了，希望以上內容可以對大家有一定的幫助，可以學到更多知識。如果覺得文章不錯，可以把它分享出去讓更多的人看到。