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