• 对象 - 有行为和状态。
• 类 - 具有相同特征的对象的集合，是抽象出来的，不是真实存在的。
• 方法 - 一个类可以包含多个方法，可以在方法中写入罗技，操作数据，以及执行动作。c++中通常叫函数。
• 即使变量 - 对个对象都有独特的即使变量，对象的状态是由这些即使变量的值创建的。

C++程序结构

#include <iostream> //头文件
using namespace std; //命名空间，std
// main() 是程序开始执行的地方
 
int main()
{
    
    
   cout << "Hello World"; // 输出 Hello World
   return 0; //终止main函数
}

编译和执行C++程序

如何将源代码保存在一个文件中呢？

• 打开一个文本编辑器（如 txt），添加上述代码
• 保存文件为hello.cpp
• 打开命令提示窗口cmd，进入到保存文件所在的目录
• 输入g++ hello.cpp，敲回车，编译代码，会生成a.out
• 输入a.out来运行程序
• 即可看到Hello World
  初学要了解这种方法，有助于了解程序的前世今生。实际开发中基本不用这种方法。

语句块

{
    
    
   cout << "Hello World"; // 输出 Hello World
   return 0;
}

是一组用大括号括起来的按逻辑连接的语句。

标识符

是用来标识变量，函数，类，模块或任何其他用户自定义项目的名称，以字母或下划线开头，后跟字母 下划线或数字
mohd zara abc move_name a_123
myname50 _temp j a23b9 retVal

关键字

三字符组

三字符组就是用于表示另一个字符的三个字符序列，又称为三字符序列。三字符序列总是以两个问号开头。

三字符序列不太常见，但 C++ 标准允许把某些字符指定为三字符序列。以前为了表示键盘上没有的字符，这是必不可少的一种方法。

三字符序列可以出现在任何地方，包括字符串、字符序列、注释和预处理指令。

下面列出了最常用的三字符序列：

如果希望在源程序中有两个连续的问号，且不希望被预处理器替换，这种情况出现在字符常量、字符串字面值或者是程序注释中，可选办法是用字符串的自动连接："…?""?..“或者转义序列：”…??.."。

从Microsoft Visual C++ 2010版开始，该编译器默认不再自动替换三字符组。如果需要使用三字符组替换（如为了兼容古老的软件代码），需要设置编译器命令行选项/Zc:trigraphs

g++仍默认支持三字符组，但会给出编译警告。

注释

• // 一般用于单行注释
• /* 。。*/ 一般用于多行注释

数据类型

七大数据类型：

1. 整型 int
2. 浮点型 float
3. 双浮点型 double
4. 字符型 char
5. 布尔型 bool
6. 无类型 void
7. 宽字符型 wchar_t

typedef short int wchar_t;

所以 wchar_t 实际上的空间是和 short int 一样。
java中是八大数据类型：byte short int long float double char boolean
下表显示了各种变量类型在内存中存储值时需要占用的内存，以及该类型的变量所能存储的最大值和最小值。
注意：不同系统会有所差异，一字节为 8 位。
注意：long int 8 个字节，int 都是 4 个字节，早期的 C 编译器定义了 long int 占用 4 个字节，int 占用 2 个字节，新版的 C/C++ 标准兼容了早期的这一设定。

变量和常量

初学的小同学肯定会搞得一头雾水，可能会被老师举的不恰当例子搞糊涂的。在这呢，就说一下我自己给他们的定义，暂时不举例子了。

• 变量：就是样子不变，值会变的量
• 常量：一般是具体的数值，值不能被修改。

如：int a ; a就是变量。a可以等于0，1，2…
变量有全局变量和局部变量，区别是位置不同，全局变量会自动初始化，而局部变量必须手动初始化。
C++也允许定义各种其他类型的变量，比如枚举、指针、数组、引用、数据结构、类等等。。。

define和const

define是预处理器，也就是全局定义好不能修改的量。

#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;
}

const关键字
声明指定类型的常量,程序中只读不能修改。

const int  LENGTH = 10;
const int  WIDTH  = 5;
const char NEWLINE = '\n';
int area;  

区别

1. 类型和安全检查不同：宏定义(#define)是字符替换，没有数据类型的区别。
2. 编译器处理不同：宏定义是编译时概念，const是一个运行时概念。
3. 存储方式不同：宏定义是直接替换，不分配内存，存储在代码段中，const需要分配内存，存储在程序的数据段中。
4. 定义域不同，宏定义是全局，const是函数内。
5. 宏定义可以#undef来取消
6. const可以当函数参数传递，宏定义不行。

const char*, char const*, char*const 的区别

修饰符类型

signed
unsigned
long
short
一段代码全明白了：

#include <iostream>
using namespace std;
/* 
 * 这个程序演示了有符号整数和无符号整数之间的差别
*/
int main()
{
    
    
   short int i;           // 有符号短整数
   short unsigned int j;  // 无符号短整数
   j = 50000;
   
   i = j;
   cout << i << " " << j;
   return 0;
}
//运行结果：-15536 50000

类型限定符

• const： const 类型的对象在程序执行期间不能被修改改变。
• volatile： 修饰符 volatile 告诉编译器不需要优化volatile声明的变量，让程序可以直接从内存中读取变量。对于一般的变量编译器会对变量进行优化，将内存中的变量值放在寄存器中以加快读写效率。
• restrict： 由 restrict 修饰的指针是唯一一种访问它所指向的对象的方式。只有 C99 增加了新的类型限定符 restrict。

存储类

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

auto
register
static
extern
mutable
thread_local (C++11)

从 C++ 17 开始，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';//错误，必须是初始化为同一类型

register

本来就是寄存器的意思，定义存储在寄存器中 而不是内存中的局部变量。意味着变量的最大尺寸等于寄存器的大小(通常是一个词)，且不能用&，因为他不在内存中。
只用于需要快速访问的变量，比如计数器。还有就是register修饰之后，并不一定存储在寄存器中，取决于硬件和实现的限制。

static

static 存储类指示编译器在程序的生命周期内保持局部变量的存在，而不需要在每次它进入和离开作用域时进行创建和销毁。因此，使用 static 修饰局部变量可以在函数调用之间保持局部变量的值。
static 修饰符也可以应用于全局变量。当 static 修饰全局变量时，会使变量的作用域限制在声明它的文件内。
在 C++ 中，当 static 用在类数据成员上时，会导致仅有一个该成员的副本被类的所有对象共享。
1). 静态成员变量是先于类的对象而存在
2). 这个类的所有对象共用一个静态成员
3). 如果静态成员是公有的，那么可以直接通过类名调用
4). 静态成员数据在声明时候类外初始化
说白了就是类变量。

#include <iostream>
 
// 函数声明 
void func(void);
 
static int count = 10; /* 全局变量 */
 
int main()
{
    
    
    while(count--)
    {
    
    
       func();
    }
    return 0;
}
// 函数定义
void func( void )
{
    
    
    static int i = 5; // 局部静态变量
    i++;
    std::cout << "变量 i 为 " << i ;
    std::cout << " , 变量 count 为 " << count << std::endl;
}

当上面的代码被编译和执行时，它会产生下列结果：

变量 i 为 6 , 变量 count 为 9
变量 i 为 7 , 变量 count 为 8
变量 i 为 8 , 变量 count 为 7
变量 i 为 9 , 变量 count 为 6
变量 i 为 10 , 变量 count 为 5
变量 i 为 11 , 变量 count 为 4
变量 i 为 12 , 变量 count 为 3
变量 i 为 13 , 变量 count 为 2
变量 i 为 14 , 变量 count 为 1
变量 i 为 15 , 变量 count 为 0

extern 存储类

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

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

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

第一个文件：main.cpp

#include <iostream>
int count ;
extern void write_extern();
int main()
{
    
    
   count = 5;
   write_extern();
}

第二个文件：support.cpp

#include <iostream>
extern int count;
void write_extern(void)
{
    
    
   std::cout << "Count is " << count << std::endl;
}

在这里，第二个文件中的 extern 关键字用于声明已经在第一个文件 main.cpp 中定义的 count。现在 ，编译这两个文件，如下所示：

$ g++ main.cpp support.cpp -o write

这会产生 write 可执行程序，尝试执行 write，它会产生下列结果：

$ ./write
Count is 5
``

mutable 存储类

mutable 说明符仅适用于类的对象，这将在本教程的最后进行讲解。它允许对象的成员替代常量。也就是说，mutable 成员可以通过 const 成员函数修改。

thread_local 存储类

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

thread_local 说明符可以与 static 或 extern 合并。

可以将 thread_local 仅应用于数据声明和定义，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;  // 本地变量
}