循环读输入，定义和声明的区别，extern，指针和引用的区别，const，常量表达式,constexpr，typedef，auto，decltype

最新推荐文章于 2022-03-23 11:36:49 发布

2020小小酥

最新推荐文章于 2022-03-23 11:36:49 发布

阅读量773

点赞数

文章标签： c++

本文链接：https://blog.csdn.net/qq_35459198/article/details/105316622

版权

第一章

cin\cout输入输出

#include<iostream>
int main(){
	int v1 = 0, v2 = 0;
	std::cin >> v1 >> v2;
	std::cout <<"v1+v2="<< v1 + v2;//拼接输出用“<<”
	return 0;
}

输出字符串常量

std::cout<<”wdadw”;
std::cout<<endl;//刷新缓冲区

不是标准库文件用include”xx.h”

循环读取输入

while (std::cin>>v1)

第二章

nullptr和NULL的区别？

nullptr是字面值；NULL是预处理变量。

默认初始化

内置类型：定义在函数体外，赋予默认值；定义在函数体内，是未定义的值。
类的对象：类决定。

定义和声明的区别？

声明：没有显示初始化

extern int i

定义：

无extern
或者有extern但是有显示初始化

注意：extern的作用域

函数体外部：extern int i=1;//定义
函数体内部：extern int i=1;//error

共享变量？extern？

不同文件中的变量的【定义和声明】都要加上extern

引用

字面值没有引用

引用分为：

左值引用：别名

int i=1;
int &d=i;

右值引用

指针和引用的区别？

指针是对象，引用不是。

指针定义

int i=2;
int *p=&i;

解引用

*p;//p是指针，*p是指针指向的内容

空指针

int *p= nullptr;//0也可以

指向指针的指针

int i=0;
int *p=&i;
int **p2=&p;

指向指针的引用int*&

int i=0;
int *p=&i;
int *&a=p;

const 对象必须初始化

extern const

不同文件可以共享

在test.cpp下

#include <iostream>
 extern const int i=1;//提供给外部文件共享i

在main.cpp下

extern const int i;//声明这里要使用外部变量
cout<<i<<endl;//1

指向常量的引用

可以戴帽子

int i=1;
const int &i2=i;//不能通过i2改变i

不能脱帽子

const int i=1;
int &i2=i;

指向常量的指针

可以戴帽子，不可以摘帽子

总结：指向常量的指针/引用的共同点都是不能通过自己改变对方（指向的物）。

简记：*右const修饰指针

指向常量的指针（只读、指向可变）

*左const：修饰指针指向的物

const double pi=3.14;
//double *pa=&pi;//指向变量的指针
const double *pb=&pi;//指向常量的指针，不能脱帽子
double b=1.1;
pb=&b;//指向可变

常量指针（读写，指向不变）

*右const：修饰指针

int a,c=0;
int *const pa=&a;//指针功能：指向不变,读写
*pa=1;
// pa=&c;//error
const int b=0;
const int *const pb=&b;//指针功能：指向不变，只读

顶层const，底层const

顶层const：是常量

底层const：针对指针的，表示指针指向的物是常量

当同时存在有顶层或底层const的对象赋值时，只有有相同底层const的对象才能相互赋值。

常量表达式

常量表达式：编译期可得，如字面值，常量表达式初始化的const。

int i=1;//不是,1是，int 不是

constexpr 变量

可以修饰变量，表示变量是个常量表达式。

可以修饰函数，在编译时就能计算出结果。

声明constexpr用到的类型，字面值类型

如算术类型，引用，指针。但是自定义类，IO类，string都不是。

constexpr指针的初始值，必须为nullptr,0,固定地址。

但是函数体内部的变量地址不固定，所以不能指向那些变量。

函数体外的变量地址不变。

但是函数可以定义函数体外的一类变量，它们地址固定，可以指向它们。

constexpr和const的区别？

注意

int i=2;
int j=3;
int main()
{
	constexpr int *p=&i;//顶层const,常量指针，读写，指向不变
	constexpr const int *p2=&j;//常量指针+只读
    return 0;
}

typedef 类型别名的两种方法

//1
typedef double wages;//wages=double
typedef wages base,*p;//base=double,p=double*
//2
using NMAE1=int;

注意：不是替换不#define

//对于复合类型，如指针，
typedef char *pstring;
const pstring cstr=0;//不是简单的替换，而是一种修饰，const修饰pstring，cstr是常量指针
const pstring *ps;//ps是指针，指向一个对象（一个常量指针）

auto

//编译器确定类型，必须有初始值
//一般会忽略顶层const（指向不变），保留底层const
const int ci=i;//顶层const
auto b=ci;//b为int类型
//
//如果希望变为顶层const,可以这样定义
const auto b2=i;//b2是const int
//
const int i=1;
auto e=&i;//对常量取地址是底层const，所以e是const int *
//
auto &h=1;//error,不可以为普通引用绑定字面值
const auto &h=1;//可以为常量引用绑定字面值

decltype类型指示符

//
decltype(f()) sum =x;//f()可以是变量或是表达式
//
int i=42,*p=&i,&r=i;
//表达式
decltype(r+0) b;//r是int&,加0，b为int
//*
//*p可以被赋值，所以是左值，所以是int&
decltype(*p) c=i;//，*p是表达式，c是int&
//(())
decltype((i));//双（）是引用，int&
decltype(i);//int

预处理器

确保头文件多次被包含，还可以正常运行

# ifndef xxx//如果不包含xxx就执行到endif
# include ...
# endif