C++笔记（一）——基础篇Ⅰ：数据类型

1. C++ 完全支持面向对象的程序设计，包括面向对象开发的四大特性：
   ·封装（Encapsulation）是将对象运行所需的资源封装在程序对象中——基本上，是方法和数据。隐藏对象的属性和实现细节，仅对外公开接口，控制在程序中属性的读取和修改的访问级别。
   ·抽象（Abstraction）包括过程抽象和数据抽象，侧重于相关的细节和忽略不相关的细节。
   ·继承（Inheritance）可以使得子类别具有父类别的各种属性和方法，而不需要再次编写相同的代码。
   ·多态（Polymorphism）指接口的多种不同的实现方式即为多态，即允许将子类类型的指针赋值给父类类型的指针。多态性在C++中都是通过虚函数实现的。
   （面向对象的三个基本特征：封装、继承、多态）

2. 标准的 C++ 由三个重要部分组成：
   ·核心语言：提供了所有构件块，包括变量、数据类型和常量，等等。
   ·C++ 标准库：提供了大量的函数，用于操作文件、字符串等。
   ·标准模板库（STL）：提供了大量的方法，用于操作数据结构等。

3. C++标准化历史
   

4. 数据类型

bool:           所占字节数：1    最大值：1                      最小值：0
char:           所占字节数：1    最大值：                       最小值：?
signed char:    所占字节数：1    最大值：                       最小值：?
unsigned char:  所占字节数：1    最大值：?                      最小值：
wchar_t:        所占字节数：4    最大值：2147483647             最小值：-2147483648
short:          所占字节数：2    最大值：32767                  最小值：-32768
int:            所占字节数：4    最大值：2147483647             最小值：-2147483648
unsigned:       所占字节数：4    最大值：4294967295             最小值：0
long:           所占字节数：8    最大值：9223372036854775807    最小值：-9223372036854775808
unsigned long:  所占字节数：8    最大值：18446744073709551615   最小值：0
double:         所占字节数：8    最大值：1.79769e+308           最小值：2.22507e-308
long double:    所占字节数：16   最大值：1.18973e+4932          最小值：3.3621e-4932
float:          所占字节数：4    最大值：3.40282e+38            最小值：1.17549e-38
size_t:         所占字节数：8    最大值：18446744073709551615   最小值：0
string:         所占字节数：24

·整数常量可以是十进制、八进制或十六进制的常量。前缀指定基数：0x 或 0X 表示十六进制，0 表示八进制，不带前缀则默认表示十进制。整数常量也可以带一个后缀，后缀是 U 和 L 的组合，U 表示无符号整数（unsigned），L 表示长整数（long）。后缀可以是大写，也可以是小写，U 和 L 的顺序任意。

85         // 十进制
0213       // 八进制
0x4b       // 十六进制
30         // 整数
30u        // 无符号整数
30l        // 长整数
30ul       // 无符号长整数

·在默认情况下，浮点常量都属于double类型。如果希望常量为float类型，请使用f或F后缀。对于long double类型，可使用L后缀。
float：2^23 = 8388608，一共七位，这意味着最多能有7位有效数字，但绝对能保证的为6位，也即float的精度为6~7位有效数字；
double：2^52 = 4503599627370496，一共16位，同理，double的精度为15~16位。

·字符常量是括在单引号中。如果常量以 L（仅当大写时）开头，则表示它是一个宽字符常量（例如 L’x’），此时它必须存储在 wchar_t 类型的变量中。否则，它就是一个窄字符常量（例如 ‘x’），此时它可以存储在 char 类型的简单变量中。字符常量可以是一个普通的字符（例如 ‘x’）、一个转义序列（例如 ‘\t’），或一个通用的字符（例如 ‘\u02C0’）。
·转义序列码

·sizeof() 函数来获取各种数据类型的大小。
·typedef 为一个已有的类型取一个新的名字。

typedef int feet;
feet distance;

5. 创建枚举，需要使用关键字 enum。
   enum 枚举名{
   标识符[=整型常数],
   标识符[=整型常数],
   …
   标识符[=整型常数]
   } 枚举变量;
   默认情况下，第一个名称的值为 0，第二个名称的值为 1，第三个名称的值为 2，以此类推。但是，您也可以给名称赋予一个特殊的值，只需要添加一个初始值即可。

enum color { red, green=5, blue };//red = 0, blue = 6

6. 左值与右值
   ·左值（lvalue）：指向内存位置的表达式被称为左值（lvalue）表达式。左值可以出现在赋值号的左边或右边。
   ·右值（rvalue）：存储在内存中某些地址的数值。右值是不能对其进行赋值的表达式，即右值可以出现在赋值号的右边，但不能出现在赋值号的左边。
7. 作用域是程序的一个区域，一般来说有三个地方可以定义变量：
   ·在函数或一个代码块内部声明的变量，称为局部变量。
   ·在函数参数的定义中声明的变量，称为形式参数。
   ·在所有函数外部声明的变量，称为全局变量。
   当局部变量被定义时，系统不会对其初始化；定义全局变量时，系统会自动初始化。
   
8. 定义常量的方式：使用 #define 预处理器；使用 const 关键字。

#include <iostream>
using namespace std;
 
#define LENGTH 10  
#define WIDTH  5
#define NEWLINE '\n'
 
int main()
{
 
   int area; 
 
   area = LENGTH * WIDTH;
   cout << area;
   cout << NEWLINE;
   return 0;
}

#include <iostream>
using namespace std;
 
int main()
{
   const int  LENGTH = 10;
   const int  WIDTH  = 5;
   const char NEWLINE = '\n';
   int area; 
 
   area = LENGTH * WIDTH;
   cout << area;
   cout << NEWLINE;
   return 0;
}

9. 数据类型修饰符：signed、unsigned、long、short。
   ·修饰符 signed、unsigned、long 和 short 可应用于整型，signed 和 unsigned 可应用于字符型，long 可应用于双精度型。
   ·修饰符 signed 和 unsigned 也可以作为 long 或 short 修饰符的前缀。例如：unsigned long int。
   ·C++ 允许使用速记符号来声明无符号短整数或无符号长整数。例如：unsigned x。
10. 类型限定符
    ·const：const 类型的对象在程序执行期间不能被修改。
    ·volatile：不需要优化volatile声明的变量，让程序可以直接从内存中读取变量。对于一般的变量编译器会对变量进行优化，将内存中的变量值放在寄存器中以加快读写效率。
    ·restrict：由 restrict 修饰的指针是唯一一种访问它所指向的对象的方式。只有 C99 增加了新的类型限定符 restrict。所有修改该指针所指向内存中内容的操作都必须通过该指针来修改。
11. 存储类定义 C++ 程序中变量/函数的范围（可见性）和生命周期，说明符放置在它们所修饰的类型之前。 C++ 程序中可用的存储类：auto、register、static、extern、mutable、thread_local (C++11)。
    从 C++ 11 开始，auto 关键字不再是 C++ 存储类说明符，且 register 关键字被弃用。

·auto：自 C++ 11 以来，auto 关键字用于两种情况：声明变量时根据初始化表达式自动推断该变量的类型、声明函数时函数返回值的占位符。C++98标准中auto关键字用于自动变量的声明，但由于使用极少且多余，在C++11中已删除这一用法。

auto f=3.14;      //double
auto s("hello");  //const char*
auto z = new auto(9); // int*
auto x1 = 5, x2 = 5.0, x3='r';//错误，必须是初始化为同一类型

①在定义模板函数时，用于声明依赖模板参数的变量类型，以及模板函数依赖于模板参数的返回值
template <typename T_x, typename T_y>
auto multiply(T_x x, T_y y){
auto z = xy;
return xy;
}
②auto 变量必须在定义时初始化，这类似于const关键字。
③如果初始化表达式是引用，则去除引用语义。
int a = 10;
int &b = a;
auto c = b;//c的类型为int而非int&（去除引用）
auto &d = b;//此时d的类型才为int&
④如果初始化表达式为const或volatile（或者两者兼有），则除去const/volatile语义。
const int a1 = 10;
auto b1= a1; //b1的类型为int而非const int（去除const）
const auto c1 = a1;//此时c1的类型为const int
⑤如果auto关键字带上&号，则不去除const语意。
const int a2 = 10;
auto &b2 = a2;//因为auto带上&，故不去除const，b2类型为const int
⑤初始化表达式为数组时，auto关键字推导类型为指针。
int a3[3] = { 1, 2, 3 };
auto b3 = a3;
cout << typeid(b3).name() << endl;//输出int *
⑥若表达式为数组且auto带上&，则推导类型为数组类型。
int a7[3] = { 1, 2, 3 };
auto & b7 = a7;
cout << typeid(b7).name() << endl;//输出int [3]
⑦函数或者模板参数不能被声明为auto。

·register ：用于定义存储在寄存器中而不是 RAM 中的局部变量，变量的最大尺寸等于寄存器的大小（通常是一个词），且不能对它应用一元的 ‘&’ 运算符（因为它没有内存位置）。寄存器只用于需要快速访问的变量，比如计数器。定义 ‘register’ 并不意味着变量将被存储在寄存器中，它意味着变量可能存储在寄存器中，这取决于硬件和实现的限制。

·static ：指示编译器在程序的生命周期内保持局部变量的存在，而不需要在每次它进入和离开作用域时进行创建和销毁。因此，使用 static 修饰局部变量可以在函数调用之间保持局部变量的值。
若 修饰全局变量，会使变量的作用域限制在声明它的文件内。

·extern ：用于提供一个全局变量的引用，全局变量对所有的程序文件都是可见的。当您使用 ‘extern’ 时，对于无法初始化的变量，会把变量名指向一个之前定义过的存储位置。
当有多个文件且定义了一个可以在其他文件中使用的全局变量或函数时，可以在其他文件中使用 extern 来得到已定义的变量或函数的引用。可以这么理解，extern 是用来在另一个文件中声明一个全局变量或函数。

·mutable ：仅适用于类的对象，它允许对象的成员替代常量。

·thread_local ：声明的变量仅可在它在其上创建的线程上访问。 变量在创建线程时创建，并在销毁线程时销毁。 **每个线程都有其自己的变量副本。**thread_local 说明符可以与 static 或 extern 合并。thread_local 仅应用于数据声明和定义，thread_local 不能用于函数声明或定义。

thread_local int x;  // 命名空间下的全局变量
class X
{
    static thread_local std::string s; // 类的static成员变量
};
static thread_local std::string X::s;  // X::s 是需要定义的
 
void foo()
{
    thread_local std::vector<int> v;  // 本地变量
}