1.0 c++的初始化

int main(){
    int a=10;
    int b(10);
    int c{0};
    int d={};//初始化为0
    int e=();//error
}

2.0输入与输出

//c语言的输入与输出
#include<stdio.h>
int main(){
    int a;
    char b;
    double c;
    scanf("%d %c %lf\n",&a,&b,&c);//输入 使用需要添加宏定义 
    printf("a=%d b=%c c=%lf\n",a,b,c);//输出 
    return 0;
}

//c++的输入与输出
#include<iostream>
using namespace std;
int main(){
    int a;
    char b;
    double c;
    cin>>a>>b>>c;//输入
    cout<<"a= "<<a<<"b= "<<b<<"c= "<<c<<endl;//输出
    return 0;
}

注意在c语言中使用scanf时需要引用宏定义

在c++中使用输入输出时 需要使用包含头文件<iostream>以及std标准命名空间

2.1输入字符串

#include<iostream>
using namespace std;
int main(){
    const int n=128;//在c语言中 n为常量 c++中 n为常变量
    char str[n];
    cin>>str;//输入字符串 yhp hello this
    cout<<str<<endl;//yhp
    cin.getline(str,n);//yhp hello this
    cout<<str<<endl;//yhp hello this
    cin.getline(str,n,'#');//yhp this # go to
    cout<<str<<endl;//yhp this
    return 0;
}

3.0 const关键字

3.1 c++与c语言中 const的区别

在c++中const以变量为主 在c语言中以常量为主

3.2 const与指针的区别

int main(){
    int a=10,b=10;
    int*p1=&a;//普通指针
    const int *p2=&a;//指针指向为常性 (解引用为常性)
    int const *p4=&a;//指针指向为常性 (解引用为常性)
    int* const p3=&a;//指针本身不能改变 为常性
    const int * const p5=&a;//指针指向与本身都为常性
}

3.3 常变量与指针

int main(){
    const int a=10;
    int*p1=&a;//error 
    const int *p2=&a;//指针指向为常性 (解引用为常性) ok
    int const *p4=&a;//指针指向为常性 (解引用为常性) ok
    int* const p3=&a;//指针本身不能改变 为常性       error
    const int * const p5=&a;//指针指向与本身都为常性 ok
    return 0;
}

3.4 兼容规程

同类型指针的赋值兼容规程

int main(){
    int a=10;
    int*p1=&a;
    int*s1=p1;//ok
    const int *p2=p1;//ok
    int const *p4=p1;//ok
    int* const p3=p1;//ok
    const int * const p5=p1;//ok
    return 0;
}

总结：能力强的指针赋值给能力收缩的指针

4.0 引用(别名)

引用的定义：类型&引用变量名称-变量名称；

这就是引用变量的定义。&和类型结合称之为引用符号，不是取地址符号 ，是别名的意思

4.1引用作为形参替代指针

使用指针交换两个整型值

void swap(int *p1,int *p2){
    int tmp=*p1;
    *p1=*p2;
    *p2=tmp
}

使用引用交换两个整型值

void swap(int& a1,int& a2){
    int tmp=a1;
    a1=a2;
    a2=tmp;
}

4.2 其他形式的引用

int main(){
    int a=10;
    int ar[5]={1,2,3,4,5};
    int* p=&a;
    int* &p=p;//引用指针
    int& x=ar[0];
    int (&br)[5]=ar;//引用数组
    return 0;
}

5.0 指针与引用的区别

指针：是一个变量，存储的是另一个对象（变量、数组、函数等）的内存地址。通过 * 运算符来访问指针所指向的对象。声明指针时，需要指定指针所指向对象的类型。

引用：是一个已存在对象的别名，本质上并不是一个独立的变量，不拥有独立的内存空间，对引用的操作实际上就是对其绑定对象的操作。声明引用时，需要在类型名后加上 &，并且在声明时必须初始化，将其绑定到一个已存在的对象上。

 内存占用

指针：本身是一个变量，会占用一定的内存空间来存储地址值。在 32 位系统中，指针通常占用 4 个字节；在 64 位系统中，指针通常占用 8 个字节。

引用：不是一个独立的变量，没有实际的内存地址（不单独分配内存来存储地址信息），只是作为对象的别名，不会额外占用内存空间。

3. 空值处理

指针：可以被赋值为 NULL（在 C++11 中推荐使用 nullptr） ，表示指针不指向任何有效的对象。在使用指针之前，通常需要检查指针是否为 NULL，以避免空指针解引用导致程序崩溃。

引用：必须在声明时绑定到一个有效的对象上，不存在空引用的概念。一旦引用被初始化，它就始终指向一个合法的对象，因此不需要像指针那样进行空值检查。

4. 初始化

指针：可以先声明，之后再进行赋值，将其指向一个有效的对象地址。也可以在声明时直接初始化。

引用：声明时必须立即初始化，将其绑定到一个已存在的对象上，一旦初始化完成，就不能再重新绑定到其他对象。

6. 作为函数参数

指针：将指针作为函数参数传递时，可以在函数内部通过修改指针所指向的值来影响实参，还可以通过修改指针本身来改变其指向（如动态内存分配时传递指针的地址，让函数内部分配的内存地址能正确返回给调用者）

引用：把引用作为函数参数传递，效果和传递指针类似，也能在函数内部修改实参的值。但引用语法更简洁，不需要使用 * 运算符去解引用，并且不用担心空引用的问题。