c++ Day01

编译器阿崽用的还是vs

输出经典的hello world

#include<iostream>
using namespace std;
int main(){
    cout<<"Hello World"<<endl;
}

初始化

使用括号或者花括号对值进行初始化

int main(){
    int a=0;
    int b(0);
    int c{0};
    int d{ };
    int e( );//error 这个是函数的声明不是赋初值
}

输入输出

小白感觉c++比c好的一点就是输入输出这里不需要考虑值的数据类型，轻松就能输入输出

#include<iostream>
using namespace std;
int main(){
    int a{ };
    double b{};
    cin>>a>>b;
    cout<<"a="<<a<<"b="<<b<<endl;
}

Notes: 1.cin：输入流对象 ，这里小白理解为把a,b的值输入到电脑里，侧重于a,b值，所以是>>

2.cout:输出流对象,将a,b的值输出，侧重在输出所以是<<

3 .>>:提取符 <<：插入符 endl相当于C语言当中的\n

4.在使用cin和cout的时候不要忘记<iostream>头文件和std

注意字符串的输入输出

#include<iostream>
using namespace std;
int main(){
    const int n=30;
    char str[n];
    cin>>str;
    cout<<str<<endl;
    return 0;
}

结果如图所示，编译器认为空格就是结束字符串所以输出空格前面的字符串

为了解决这一问题使用getline

#include<iostream>
using namespace std;
int main(){
    const int n=30;
    char str[n];
    cin.getline(str,30);
    cout<<str<<endl;
    return 0;
}

可以完整输出

如果还想添加结束标志还可以在getline的基础上在加一点

#include<iostream>
using namespace std;
int main(){
    const int n=30;
    char str[n];
    cin.getline(str,30,'#');
    cout<<str<<endl;
    return 0;
}

#标准结束输入字符串

const

const 在c和c++区别

c:const修饰的常变量更侧重于变量

c++:const修饰的常变量更侧重于常量

在数组定义方面

c:

int main(){
    const int n=10;
    int ar[n]={0,1,2};//error   VS显示表达式必须含有常量值，说明在c更偏向与变量
}

c++：

int main(){
    const int n=10;
    int ar[n]={1,2,3,4,5};//ok
}

在指针方面

c:

int main(){
    const int n=5;
    int*p=(int*)&n;
    *p=10;
    printf("n=%d,*p=%d",n,*p);
}

说明可以通过*p去改变n的值

c++:

#include<iostream>
using namespace std;
int main() {
    int n = 5;
    int* p = (int*)&n;
    *p = 100;
    cout << "n=" << n << "*p=" << *p << endl;
}

在C++ 编译的时，当碰到用const修饰的变量时，编译器是直接将变量的值和变量的符号对应起来，例如const int a = 5;在符号表中就会将a和5对应起来，在编译的过程中。当碰到 n=a,直接把5替换a;

const与指针的关系

首先先来说说指针

指针有两个方面一个是他自身的值，另外一个是他解引用的值（指向的值）；

int *p=&a;

*p解引用可以改变a的值

p=&b;

指针p也可以指向b

int main(){
    int a=10,b=20;
    int*p1=&a;
    const int *p2=&a;//限定了指针p2不能通过解引用改变a的值，但是p自身可以指向其他地址
    int*const p3=&a;//限定了指针p3不能指向其他地址，只能指向a，但是可以通过解引用来改变a的值
    const int*const p4=&a;//既限定了指针p4不能指向其他地址，又不能通过解引用来改变a的值
    printf("a=%d,*p1=%d,*p2=%d,*p3=%d,*p4=%d", a, *p1, *p2, *p3, *p4);
}

int main(){
    const int a=1;//const修饰的a值是不能被改变的
    int *p1=&a;//error  我们可以通过p1指针解引用来改变a的值
    const int*p2=&a;//ok  限定了p指针解引用去改变a的值
    int *const p3=&a;//error  只限定了p自身的值，并不妨碍我们通过解引用来改变a的值
    const int* const p4=&a;//ok  以上的两个都限定了
}

int main(){
    int a=5;
    const int*p=&a;//我们不能通过解引用来改变a的值
    int*s1=p;//error 我们可以通过指针s1解引用得到p然后进而改变a的值
    const int*s2=p;//ok
    int*const s3=p;//error 只是限定了s3的自身值，并不影响解引用
    const int*const s4=p;
}

引用

基础概念

数据类型+&+变量名=变量名；

&和类型结合是引用，没有类型是取地址

int *p=&a;取地址

int &p=a;a的别名是p

 

int main(){
    int a{10};
    int &c=a;
    a+=10;
    c+=10;
    cout<<"a="<<a<<"c="<<c<<endl;//a=30,c=30;
    cout<<"&a="<<&a<<"&c="<<&c<<endl;//地址是一样的，引用与其所指向的变量共用同一块内存空间 
}

比起指针来说不需要判空

注意：

不能定义空引用；

定义引用的时候必须初始化；

没有二级引用；int &&a=c//不是二级引用

可以 int &a=c;int&b=a;

实例：利用引用来交换两个数

#include<iostream>
using namespace std;
void swap(int &a,int&b){
    int t=a;
    a=b;
    b=t;
}
int main(){
    int x=1,y=2;
    cout<<"x="<<x<<"y="<<y<<endl;
    swap(x,y);
    cout<<"x="<<x<<"y="<<y<<endl;
}

const和引用

int main(){
    int a=10;
    int const &c=a;
    cout<<c<<endl;
    c+=10;//error c可以读取a的值，但不能修改c因为c是一个常值
    int &const d=&a;
    d+=10;//ok  const 忽略
    const  int x=10;
    const int &u=x;//要用常引用，防止通过引用来改变常值x
}

数组与引用

int main(){
    int arr[3]={1,2,3}；
    int &a=arr[1];//a=2
    int &brr[3];//error 开辟三个空间存储整型类型的引用，数组需要开辟空间，而引用与其所指向的变量共用同一块内存空间 ，不需要开辟，两者矛盾所以错误
    int (&crr)[3]=arr;//ok 引用arr整个数组
}

引用指针

int main(){
    int a=10;
    int*p=&a;//指针p指向a
    int&x=a;//a的别名是x
    int*s=p;//指针s指向p
    int&*ps=p;//error 定义一个指针指向引用p
    int *&y=p;//指针类型的引用y，
}

指针与引用的区别

1.指针存储的是某个值的地址，引用是某个变量的别名

2.编译器为指针分配内存，但是引用与其所指向的变量共用同一块内存空间，不需要开辟空间

3.输出指针指向的值需要解引用，而引用不需要

4.指针自身指向可以发生改变 如int*p=&a,p=&b;

而引用在定义的时候初始化后就不能改变。

5.指针可以是空指针但是引用不能是空引用

6.函数里面指针作为形参需要判空，而引用不需要

7.sizeof里面的指针大小就是指针变量的大小，而引用却是变量的大小

8.指针存在一级指针，二级指针等等，但是引用只有一级

9.++引用与指针效果不一样

int main(){
    int arr[5]{1,2,3,4,5};
    int &a=ar[0];//1
    int*p=&a[0];
    ++a;//ar[0]=2
    ++p;//ar[1]
}

指针++：指向下一个元素，不会改变变量或者对象

引用++：引用的值加1

int &x===>int const*x;

限定自身只能指向初始化的那个数值，不能改变