C++ 小白学习记录--2

最新推荐文章于 2024-08-09 10:25:03 发布

yutao1131

最新推荐文章于 2024-08-09 10:25:03 发布

阅读量118

点赞数

分类专栏： c++学习文章标签： c++

本文链接：https://blog.csdn.net/yutao1131/article/details/117463300

版权

c++学习专栏收录该内容

18 篇文章 0 订阅

订阅专栏

c++博大精深, 越看越觉得不会的太多. 回炉一下吧~ 大神们请勿浪费时间~

第二章

细节比较多

2.1 算术类型和空类型空类型比较常见的就是void 函数无返回值时. 算术类型整型浮点型. 长度不同机器不同, c++只规定各种类型最短尺寸!!

一个char的大小和一个几个机器字节一样

一个int>=short, long >=int, long long >=long 类型长度的定义很有意思.

int short long long long 有有符号和无符号两种而 char 则有三种, 编译器决定了char是有符号还是无符号的这个为啥要这样定义啊? 所以使用char还是明确使用signed char 还是 unsigned char

选择数据类型的推荐方案:

1. 明确知道数据不可能为负时, 选无符号的

2. 如果数值有可能超过int , 直接 long long

3. signed char or unsigned char 而 ~~char~~ 就当不存在吧

4. 浮点就 double

2.2 类型转换假设char占8位

1. bool 只认 0 和非零, 转换到int 就只有0 1

2. signed char c2 =256 超出返回则认为c2 未定义

3. unsigned char c = -1, 涉及到原码反码补码, 正数原反补一样

负数 -1=[10000001]原 = [11111110]反 = [11111111]补作为正数结果就是255, 快速方法是将-n 赋值给unsigned char = -n+256

字符面值常量 20(十进制) = 0x14(十六进制) = 024(八进制)

单引号字符字面值, 双引号"hello world" 字符串字面值, 字符串字面值的长度=实际长度+1, 结尾 '\0'

转义字符 \n \v \t \b 等

指定字面值的类型字符类型在字符前面如 L'a' u8"hi" 数值在后 42 ULL 1E-3F 3.1415L

2.3 变量 {} () = 的区别

函数体外的变量会自动给个默认值, 函数体内的不会自动初始化, 直接使用会报错

long double ld = 3.1415926

int a{ld}, b={ld} 大括号如果存在丢失信息的风险则报错

int a(ld), b = ld 这种初始化会丢信息,但是不报错.

声明和定义的区别

只声明使用extern, 可以声明多次, 未申请空间未初始化

定义, 只能定义一次, 申请空间了

作用域: 局部变量会覆盖全局变量, 如需使用全局变量需要使用::

int p44() {
   int unique = 0;
   std::cout << reused << " " << unique << std::endl;
   int reused = 22;
   for (int reused = 0; reused < 2; ++reused) {
       std::cout << reused << " in for1 " << unique << std::endl; // 输出 0 0
       // todo 如何使用外部的reused, 即 reused=22 这个呢?
       std::cout << ::reused << " in for2 " << unique << std::endl; // 输出 42 0
   }
   std::cout << reused << " " << unique << std::endl; // 输出 22 0
   std::cout << ::reused << " " << unique << std::endl; // 输出 42 0
   return 0;
}

引用 &

1. 引用=别名不是对象, 一旦定义将无法再绑定到其余的对象

2. 引用必须被初始化

3. 引用不能定义引用

4. 不能用字面值常量定义引用如int &ref=10

指针 * 取地址& 如 int i =42, int *p = &i; 使用 cout<< *p 输出42

1. 指针是对象, 允许对指针赋值和拷贝, 可以先后指向不同的对象

2. 无须在定义时赋初值

定义空指针时不能使用变量如下:

   int zero = 0;
   int* p = 0; //可以这么定义空指针
   int* p1 = zero; // 不能这样定义空指针
   int* p2 = nullptr; //建议如此定义空指针

指针定义时初始化和再定义时不同

   int ival = 1024;
   int* p1 = 0;
   int* p2 = &ival;
   p1 = &ival; //p1 是地址 *p1 是指向的对象

void* 用于存放任意对象的地址, 该地址中的对象未知; 类似于其他语言中的object, 用于装箱, 然后将来拆箱. 因为指向的对象未知, 所以不能直接操作该指针指向的对象.

指向指针的引用这个太绕了

   int z = 42;
   int *p;
   int *&r = p; // r是一个对指针p的引用

// 从右向左分析: 离r最近的修饰符是&, 则r是一个引用. 再往左是*, 则说明r引用的是指针, 最后是int
r = &i; // 因r是引用, 可以直接替换r为p 理解
*r = 0; // 因r是引用, 可以直接替换r为p 理解

const 一旦创建就不能再改变, 必须初始化(编译时初始化, 运行时初始化) 文件级别的作用域, 如果想跨文件作用域需要使用 extern const int bufSize=124;

const int readOnly = 200;
   const int& refReadOnly = readOnly;
   int readOnly2 = 100;
   const int& refReadOnly2 = readOnly2;
   int& refReadOnly3 = readOnly2;
   readOnly2 = 21;
   refReadOnly2 = 20; // 错误不能修改值
   refReadOnly3 = 222; // 正确可以修改值

可以定义一个常量引用, 保护可以修改的变量不被修改. 指针也可以这样

int &r1=42 (x) const int &r1 = 42 (√)

注意以下指针定义的区别

int i=10;

const int *p = &i; // *p不能修改, *p是const 值不能变

int *const p = &i; // p不能修改而 *p 指向的对象值可以修改地址不能变必须定义时初始化

const int *const p =&i // 值和地址都不能变

顶层const 指针本身是常量, 即地址是常量

底层const 指针所指对象是常量

转换时 非常量转换为常量可以反之则不行( 只针对底层 const, 顶层不受影响)

这个比较难, 下面是例子:

int i = 0;
   int* const p1 = &i;
   const int ci = 42;
   const int* p2 = &ci;
   const int* const p3 = p2;
   const int& r = ci;

   int* p = p3; // 错误, p3 含有const, p 没有
   p2 = p3; // 正确, p3 p2 都具有底层const
   p2 = &i; // 正确, int * 可以转 const int * 即非常量转常量
   int& r = ci; //错误, ci是常量, 常量不能被非常量绑定
   const int& r2 = i; // 正确, const int&可以绑定到一个常量上

常量表达式: 值不会改变且在编译过程就能得到计算结果的表达式. 字面值,const对象都是

const int sz=get_size(); // 这种不是常量表达式

constexpr 由编译器来验证变量值是否是一个常量表达式.

const int *p = nullptr; // p 是一个指向整型常量的指针 p可以变, *p不能变

constexpr int *q = nullptr;

// q 是一个指向整数的常量指针, q不能变, *q可以变. 类似 int *const q=nullptr

constexpr const int *p =nullptr; // 实现双锁定

constexpr 仅对指针有效, 与其所指的对象无关

类型别名 typedef 这个很难理解, 必须把typedef 定义的内容作为一个整体来看, 不能原样带入, 原样带入后会出现理解错误. 例如下面的例子. 所以不能简单的通过带入理解, 需要把typedef定义的类型作为一个整体来理解

   char a = 'a';
   typedef char* pstring;
   const pstring cstr = 0;
   cstr = 1; // 错误 cstr 值是常量
   *cstr = 1; // 正确, *cstr指向的对象不是常量
   const char* cstr2 = 0;
   cstr2 = &a; // 正确 cstr2 不是常量
   *cstr2 = 'b'; // 错误 cstr2 指向的对象是常量
   char* const cstr3 = 0; // typedef的等效定义
   cstr3 = 1; // 错误 cstr3 是常量
   *cstr3 = 1; // 正确 cstr3 指向的对象不是常量

auto类型必须有初始值, 编译器自动分析类型. 好像var, let ?

auto一次定义多个变量时, 变量类型应该一致.

auto一般会忽略顶层const, 需要显示声明

int i=0;

const int ci =i, &cr=ci;

auto e = &ci; // e 指向整数常量的指针常量取地址是一种底层const

auto f1 = ci; // 顶层const 被忽略掉. 相当于int f1 = ci

const auto f =ci;

decltype 获取操作/函数的类型, 但是不使用该操作/函数初始化变量

int i=42, *p=&i, &r=i;

decltype(r+0) b; // b 的类型为int , 因为r+0运算后结果为int

decltype(*p) c = i; // c为int& 引用类型, 引用类型必须初始化. 如果是解引用则使用引用类型