C++系列之基础知识

数据类型

7种基本的C++数据类型

类型	关键字	占用内存 sizeof(类型关键字)
布尔型	bool	1B
字符型	char	1B
整型	int	4B
浮点型	float	4B
双浮点型	double	8B
无类型	void
宽字符型	wchar_t	2B
字符串型	string	24B

一些基本类型可以使用一个或多个类型修饰符进行修饰：

• signed: 默认

• unsigned: 取值范围从0开始

• short: 内存大小折半

• long: 内存大小double

typedef声明

可以使用 typedef 为一个已有的类型取一个新的名字。下面是使用 typedef 定义一个新类型的语法：
typedef type newname;

例如，下面的语句会告诉编译器，feet 是 int 的另一个名称：

typedef int feet;

现在，下面的声明是完全合法的，它创建了一个整型变量 distance：
feet distance;

枚举类型

创建枚举，需要使用关键字 enum。枚举类型的一般形式为：

enum 枚举名{ 

     标识符[=整型常数], 
     标识符[=整型常数], 
... 
    标识符[=整型常数]

} 枚举变量;

如果枚举没有初始化, 即省掉"=整型常数"时, 则从第一个标识符开始。

例如，下面的代码定义了一个颜色枚举，变量 c 的类型为 fruit。最后，c 被赋值为 "orange"。

enum fruit { banana, apple, orange } c;
c = orange;

默认情况下，第一个名称的值为 0，第二个名称的值为 1，第三个名称的值为 2，以此类推。但是，您也可以给名称赋予一个特殊的值，只需要添加一个初始值即可。例如，在下面的枚举中，apple 的值为 5。

enum fruit { banana, apple=5, orange };

在这里，orange 的值为 6，因为默认情况下，每个名称都会比它前面一个名称大 1，但 banana 的值依然为 0。

变量声明与定义

变量的定义用于为变量分配存储空间，还可以为变量指定初始值。在一个程序中，变量有且仅有一个定义。

声明用于向程序表明变量的类型和名字。定义也是声明：当定义变量时我们声明了它的类型和名字。可以通过使用 extern 关键字声明变量名而不定义它。不定义变量的声明包括对象名、对象类型和对象类型前的关键字 extern。

  extern int i; // 声明但不定义
  int i;   // 声明也定义

定义不应该放在头文件中。

extern 声明不是定义，也不分配存储空间 事实上，它只是说明变量定义在程序的其他地方。程序中变量可以声明多次，但只能定义一次。

// 函数声明
int func();
 
int main()
{
    // 函数调用
    int i = func();
}
 
// 函数定义
int func()
{
    return 0;
}

常量

整数常量可以是十进制、八进制或十六进制的常量。前缀指定基数：0x 或 0X 表示十六进制，0 表示八进制，不带前缀则默认表示十进制。

整数常量也可以带一个后缀，后缀是 U 和 L 的组合，U 表示无符号整数（unsigned），L 表示长整数（long）。后缀可以是大写，也可以是小写，U 和 L 的顺序任意。

下面列举几个整数常量的实例：

212         // 合法的 
215u        // 合法的 
0xFeeL      // 合法的 
078         // 非法的：8 不是八进制的数字 
032UU       // 非法的：不能重复后缀

以下是各种类型的整数常量的实例：

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

浮点常量由整数部分、小数点、小数部分和指数部分组成。您可以使用小数形式或者指数形式来表示浮点常量。

当使用小数形式表示时，必须包含整数部分、小数部分，或同时包含两者。当使用指数形式表示时， 必须包含小数点、指数，或同时包含两者。带符号的指数是用 e 或 E 引入的。

下面列举几个浮点常量的实例：

3.14159       // 合法的  
314159E-5L    // 合法的  
510E          // 非法的：不完整的指数 
210f          // 非法的：没有小数或指数 
.e55          // 非法的：缺少整数或分数

字符常量

字符串常量

定义常量

在 C++ 中，有两种简单的定义常量的方式：

• 使用 #define 预处理器。#define identifier value

• 使用 const 关键字。const type variable = value;

C++存储类

存储类定义 C++ 程序中变量/函数的范围（可见性）和生命周期。这些说明符放置在它们所修饰的类型之前。下面列出 C++ 程序中可用的存储类：

• auto：auto 关键字用于两种情况：声明变量时根据初始化表达式自动推断该变量的类型、声明函数时函数返回值的占位符。

  C++98标准中auto关键字用于自动变量的声明，但由于使用极少且多余，在 C++17 中已删除这一用法。

  根据初始化表达式自动推断被声明的变量的类型，如：

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

• register：register存储类用于定义存储在寄存器中而不是 RAM 中的局部变量。这意味着变量的最大尺寸等于寄存器的大小（通常是一个词），且不能对它应用一元的 '&' 运算符（因为它没有内存位置）。

  { register int miles; }

  寄存器只用于需要快速访问的变量，比如计数器。还应注意的是，定义 'register' 并不意味着变量将被存储在寄存器中，它意味着变量可能存储在寄存器中，这取决于硬件和实现的限制。

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

  static 修饰符也可以应用于全局变量。当 static 修饰全局变量时，会使变量的作用域限制在声明它的文件内。

  在 C++ 中，当 static 用在类数据成员上时，会导致仅有一个该成员的副本被类的所有对象共享。

• extern：extern 存储类用于提供一个全局变量的引用，全局变量对所有的程序文件都是可见的。当您使用 'extern' 时，对于无法初始化的变量，会把变量名指向一个之前定义过的存储位置。

  当您有多个文件且定义了一个可以在其他文件中使用的全局变量或函数时，可以在其他文件中使用 extern 来得到已定义的变量或函数的引用。可以这么理解，extern 是用来在另一个文件中声明一个全局变量或函数。

  extern 修饰符通常用于当有两个或多个文件共享相同的全局变量或函数的时候。

• mutable：仅适用于类的对象，它允许对象的成员替代常量。也就是说，mutable 成员可以通过 const 成员函数修改。

• thread_local (C++11)：使用 thread_local 说明符声明的变量仅可在它在其上创建的线程上访问。 变量在创建线程时创建，并在销毁线程时销毁。 每个线程都有其自己的变量副本。

循环

判断

函数

指针

指针是一个变量，其值为另一个变量的地址，即，内存位置的直接地址。就像其他变量或常量一样，您必须在使用指针存储其他变量地址之前，对其进行声明。指针变量声明的一般形式为：

type *var-name;

在这里，type 是指针的基类型，它必须是一个有效的 C++ 数据类型，var-name 是指针变量的名称。用来声明指针的星号 * 与乘法中使用的星号是相同的。但是，在这个语句中，星号是用来指定一个变量是指针。以下是有效的指针声明：

int    *ip;    /* 一个整型的指针 */
double *dp;    /* 一个 double 型的指针 */
float  *fp;    /* 一个浮点型的指针 */
char   *ch;    /* 一个字符型的指针 */

所有指针的值的实际数据类型，不管是整型、浮点型、字符型，还是其他的数据类型，都是一样的，都是一个代表内存地址的长的十六进制数。不同数据类型的指针之间唯一的不同是，指针所指向的变量或常量的数据类型不同。

#include <iostream>
 
using namespace std;
 
int main ()
{
   int  var = 20;   // 实际变量的声明
   int  *ip;        // 指针变量的声明
 
   ip = &var;       // 在指针变量中存储 var 的地址
 
   cout << "Value of var variable: ";
   cout << var << endl;
 
   // 输出在指针变量中存储的地址
   cout << "Address stored in ip variable: ";
   cout << ip << endl;
 
   // 访问指针中地址的值
   cout << "Value of *ip variable: ";
   cout << *ip << endl;
 
   return 0;
}

运行结果：
Value of var variable: 20
Address stored in ip variable: 0xbfc601ac
Value of *ip variable: 20

概念	描述
C++ Null 指针	C++ 支持空指针。NULL 指针是一个定义在标准库中的值为零的常量。
C++ 指针的算术运算	可以对指针进行四种算术运算：++、--、+、-
C++ 指针 vs 数组	指针和数组之间有着密切的关系。
C++ 指针数组	可以定义用来存储指针的数组。
C++ 指向指针的指针	C++ 允许指向指针的指针。
C++ 传递指针给函数	通过引用或地址传递参数，使传递的参数在调用函数中被改变。
C++ 从函数返回指针	C++ 允许函数返回指针到局部变量、静态变量和动态内存分配。

引用

引用变量是一个别名，也就是说，它是某个已存在变量的另一个名字。一旦把引用初始化为某个变量，就可以使用该引用名称或变量名称来指向变量。

C++ 引用 vs 指针

引用很容易与指针混淆，它们之间有三个主要的不同：

• 不存在空引用。引用必须连接到一块合法的内存。

• 一旦引用被初始化为一个对象，就不能被指向到另一个对象。指针可以在任何时候指向到另一个对象。

• 引用必须在创建时被初始化。指针可以在任何时间被初始化。

C++ 中创建引用

试想变量名称是变量附属在内存位置中的标签，您可以把引用当成是变量附属在内存位置中的第二个标签。因此，您可以通过原始变量名称或引用来访问变量的内容。例如：

int i = 17;

我们可以为 i 声明引用变量，如下所示：

int&  r = i;
double& s = d;

在这些声明中，& 读作引用。因此，第一个声明可以读作 "r 是一个初始化为 i 的整型引用"，第二个声明可以读作 "s 是一个初始化为 d 的 double 型引用"。下面的实例使用了 int 和 double 引用：

实例

#include <iostream>
 
using namespace std;
 
int main ()
{
   // 声明简单的变量
   int    i;
   double d;
 
   // 声明引用变量
   int&    r = i;
   double& s = d;
   
   i = 5;
   cout << "Value of i : " << i << endl;
   cout << "Value of i reference : " << r  << endl;
 
   d = 11.7;
   cout << "Value of d : " << d << endl;
   cout << "Value of d reference : " << s  << endl;
   
   return 0;
}
运行结果：
Value of i : 5
Value of i reference : 5
Value of d : 11.7
Value of d reference : 11.7

引用通常用于函数参数列表和函数返回值。下面列出了 C++ 程序员必须清楚的两个与 C++ 引用相关的重要概念：

概念	描述
把引用作为参数	C++ 支持把引用作为参数传给函数，这比传一般的参数更安全。
把引用作为返回值	可以从 C++ 函数中返回引用，就像返回其他数据类型一样。

数据结构

C/C++ 数组允许定义可存储相同类型数据项的变量，但是结构是 C++ 中另一种用户自定义的可用的数据类型，它允许您存储不同类型的数据项。

定义结构：

struct type_name {
member_type1 member_name1;
member_type2 member_name2;
member_type3 member_name3;
.
.
} object_names;

其他

• 数组

• C++修饰符类型：signed unsigned long short const volatile restrict

• 三字符组概念

• 注释

  块注释符（/.../）是不可以嵌套使用的。

#if 0 ... #endif 属于条件编译，0 即为参数。

此外，我们还可以使用 if 0 ... #endif 来实现注释，且可以实现嵌套，格式为：

#if 0
   code
#endif 

你可以把 #if 0 改成 #if 1 来执行 code 的代码。

这种形式对程序调试也可以帮助，测试时使用 #if 1 来执行测试代码，发布后使用 #if 0 来屏蔽测试代码。

#if 后可以是任意的条件语句。

下面的代码如果 condition 条件为 true 执行 code1 ，否则执行 code2。

#if condition
  code1
#else
  code2
#endif