c++day2 const

void main01()
{
    const int a;
    int const b;//一样

    const int *c;//const修饰的是指针所指向的内存空间不能被修改
    int * const d;//值不可以被修改
    const int * const e;//指针不可以被修改
    cout<<"hello.."<<endl;
    system("pause");
    return ;
}

//说明C语言中的const存在缺陷，可以间接修改,而在C++里面，a的值是10
void main02()
{
    //好像a是一个常量
    const int a =10;
    //a  = 11;
    int *p = NULL;
    p = (int *)&a;

    *p = 20;//间接赋值
    printf("%d\n",a);
    //cout<<a<<endl;
}

C++编译器对const的处理，虽然可能为const常量分配空间，但是不会使用其存储空间内的值。其实是一个类似map的符号表，当用到的时候就会从表中读取，是不会变的

const分配内存的时间是编译器编译期间。

void main03()
{
    int a ;
    const int b;
    int c;
    printf("%d,%d,%d\n",&a,&b,&c);
//打印结果是三个连续的内存地址

    system("pause");

}

04const的用途
宏定义的手段，
//下面的代码如果不用const就会报错
int main04()
{
    const int a=1;
    const int b=2;
    int array[a+b] ={0};
    int i=0;
    for(i=0;i<(a+b);i++)
    {
        printf("array[%d]=%d\n",i,array[i]);    
    }    
    
    printf("press enter to continue...");
    getchar();
    
    return 0;
}

//注意，如果是linux内核里的编码，不加const也可以编译通过，这是由于gcc编译器的支持，但是c和c++都不支持这种不安全的写法。

#define是预处理，但是const是编译处理，这是区别

05const定义的变量，由编译器处理提供类型检查和作用域检查
#define作用域比const大，const的作用域很确切。

引用
a)在c++中引入了引用的概念
b）引用可以看作是已经定义变量的别名
c）引用的语法是 ：Type& name = var;
d)引用作为函数参数声明时候不进行初始化。

#include <iostream>
using namespace std;

void main(){
    int a =10;
    //引用
    int &b =a ;
    
    b=100;

    printf("b:%d\n",b);
    printf("a:%d\n",a);

    cout<<"hello"<<endl;

    system("pause");

    return ;
}
//类似指针的作用，引用也是可以间接赋值，其实可以这么理解
int &b=a;
int *b= a;//不能再用c语言的语法去思考c++

 

普通引用必须用其他的变量进行初始化

void myswap(int &a,int &b){
    int c=0;
    c =a ;
    a=b;
    b=c;
}
//相比c，引用的思想很方便。引用比指针要更简单些。
//一定情况下，引用可以替代指针发挥作用
//引用相对于指针来说具有更好的可读性

struct Teacher{
    char name[32];
    int age;
};
void  pT(Teacher *pt){
    cout<<pt->age<<endl;
}
void pT1(Teacher &pT1){
    cout<<pT1.age<<endl;
}
void pT2(Teacher pT){
    cout<<pT.age<<endl;
}
void main(){

    Teacher t1 ;
    t1.age = 35;

    pT(&t1);
    pT1(t1);//pt是t1的别名
    pT2(t1);//pT是形参，t1拷贝了一份数据给pT
    system("pause");

}

引用的本质
#include<iostream>
using namespace std;

void main(){
    const int c1 = 10;
    int z = 10;
    int &s= z;//b很像一个常量

    printf("&z:%d",&z);
        printf("&s:%d",&s);
//发现这两个地址一样

        system("pause");
        return ;
}
//引用其实就是同一个内存空间的门牌号

struct Teacher
{
        char name[64];
        int age;

        int &f;
        int &g;
};
void main()
{
    cout<<sizeof(Teacher)<<endl;
    system("pause");
}

//打印结果76，所以引用变量也分配了一个内存空间。

引用在c++内部实现是一个常量指针，因此引用所占用的空间大小与指针相同

//间接赋值条件
a）2个变量，一个形参，一个实参
b）实参取地址传递给形参,建立关联
c）改变形参指向，间接修改实参的值

void modify(int *p){
    int a =20;
    int *p = null;
    
    p = &a;
    *p = 100;

}

//当我们使用引用时，不需要考虑编译器怎样实现引用的
//但是debug和release运行不同情况可能出现不同的结果，这个时候就要考虑出现乱码的原因。

//函数当左值，返回变量的值

//引用当左值，返回的是变量的地址，当做引用时可以间接赋值，但是如果右值同样是一个局部变量地址，就会出现乱码。关键是看空间是有效空间，不能是局部内存空间。

//引用当右值，就不会再修改了，情况就会变得简单很多。