快捷導航

C++中需要注意的細節(jié)你知道嗎

更新時間：2021年09月18日 10:15:28 作者：睡不飽的小默

這篇文章主要介紹了C++ 需要注意的幾點細節(jié)，幫助大家更好的理解和學習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-->由預(yù)處理器處理,單純的文本替換
//                       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時會給常量分配內(nèi)存空間
    fun1();
    fun2();
    getchar();
    return 0;
}

引用

//引用的本質(zhì)：
//          1 引用在C++內(nèi)部實現(xiàn)是一個常指針   Type &name --> Type * const name
//          2 C++編譯器在編譯過程中使用常指針作為引用的內(nèi)部實現(xiàn).因此所占用的空間與指針一樣大 4
//          3 C++為引用的使用做了細節(jié)隱藏
/*
    函數(shù)返回值是引用：
           1  難點注意：要觀察返回的變量是在哪里分配內(nèi)存空間的--->如果是臨時變量，即在棧上分配內(nèi)存,函數(shù)返回時會被析構(gòu)(釋放)
                            --> 不能作為左值使用，因為空間被釋放了。沒地方存了
                            --> 不能成為其它引用的初始值,空間被釋放了
           2  c++鏈式編程編程、操作符重載
*/
/*
    指針的引用-->只不過是為存儲指針的這塊內(nèi)存取了個別名而已
*/
#include <iostream>
using namespace std;
//證明引用有自己的內(nèi)存空間
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);  
    //對同一內(nèi)存空間可以取好幾個名字嗎？    -->   不行
    //實際上：int const *b = &a     &b:編譯器會幫我們做 *(&b) 
    return 0;
}
//引用做函數(shù)返回值
int f1()
{
    int a;
    a = 10;
    return a;
}
int &f2()
{
    int a;
    a = 20;
    return a;
}
int *f3()
{
    int a;
    a = 30;
    return &a;
}
//---> 害，其實就一句話,看內(nèi)存有沒有被釋放而已
//static + &引用
int j()             //-->返回的只是一個數(shù)值而已
{
    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()-->返回的是一個數(shù)值,不能當左值  11 = 100(err)
    j2() = 100;
    j2();
    //手工打造引用條件
    *(j3()) = 100;
    j3();
    getchar();
    return 0;
}
//非基礎(chǔ)類型：可能設(shè)計到深拷貝和淺拷貝的問題-->其實也就是有沒有內(nèi)存空間的問題
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;
}

函數(shù)相關(guān)

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