C++修行

• **C++基础篇**
  • **C++数据类型**
  • **C++变量类型**
    • C++中的变量定义
    • **C++中的变量声明**
  • **C++ 变量作用域**
  • **C++修饰符类型**
  • **C++存储类**
    • **解释：**
    • **auto 存储类：**
    • **register 存储类：**
    • **static 存储类：**
    • **extern 存储类：**
    • **mutable 存储类：**
    • **thread_local 存储类：**
  • **C++数组\字符串**
    • **数组**
      • **声明数组**
      • **初始化数组**
    • **C++字符串**
      • **C风格字符串**
      • **C++中的String类**
  • **C++指针**
    • **什么是指针**
    • **C++中使用指针**
    • **C++指针详解**
  • **C++引用**
  • **C++日期&时间**
  • **C++基本的输入输出**
    • **I/O 库头文件**
    • **标准输出流(cout)**
    • **标准输入流(cin)**
    • **标准错误流（cerr）**
    • **标准错误流（cerr）**
  • **C++ 数据结构**
    • **定义结构**
    • **访问结构成员**

C++基础篇

C++数据类型

• 定义：使用编程语言进行编程时，需要用到各种变量来存储各种信息。变量保留的是它所存储的值的内存位置。这意味着，当您创建一个变量时，就会在内存中保留一些空间。您可能需要存储各种数据类型（比如字符型、宽字符型、整型、浮点型、双浮点型、布尔型等）的信息，操作系统会根据变量的数据类型，来分配内存和决定在保留内存中存储什么。

  类型	关键字
  布尔型	bool
  字符型	char
  整型	int
  浮点型	float
  双浮点型	double
  无类型	void
  宽字符型	wchar_t

C++变量类型

• 解释：
  • 变量其实只不过是程序可操作的存储区的名称。C++ 中每个变量都有指定的类型，类型决定了变量存储的大小和布局，该范围内的值都可以存储在内存中，运算符可应用于变量上。
  • 变量的名称可以由字母、数字和下划线字符组成。

• C++中的变量定义

  • 解释： 变量定义就是告诉编译器在何处创建变量的存储，以及如何创建变量的存储
  • 示例：

  ---

  int    i, j, k;
  char   c, ch;
  float  f, salary;
  double d;
  

  ---

• C++中的变量声明

  ---

  • 解释： 变量声明向编译器保证变量以给定的类型和名称存在，这样编译器在不需要知道变量完整细节的情况下也能继续进一步的编译。变量声明只在编译时有它的意义，在程序连接时编译器需要实际的变量声明。当您使用多个文件且只在其中一个文件中定义变量时（定义变量的文件在程序连接时是可用的），变量声明就显得非常有用。您可以使用 extern 关键字在任何地方声明一个变量。虽然您可以在 C++ 程序中多次声明一个变量，但变量只能在某个文件、函数或代码块中被定义一次。

  ---

  #include 
  using namespace std;
  // 变量声明
  extern int a, b;
  extern int c;
  extern float f;
  
  int main (www.xkfyz.com)
  {
       // 变量定义
      int a, b;
      int c;
      float f;
  
      // 实际初始化
      a = 10;
      b = 20;
      c = a + b;
      
      cout << c << endl ;
      
      f = 70.0/3.0;
      cout << f << endl ;
      
      return 0;
  }
  

C++ 变量作用域

• 在函数或一个代码块内部声明的变量，称为局部变量
• 在函数参数的定义中声明的变量，称为形式参数
• 在所有函数外部声明的变量，称为全局变量

C++修饰符类型

• 数据类型修饰符：
  • signed
  • unsigned
  • long
  • short
• signed、unsigned、long 和 short 可应用于整型
• signed 和 unsigned 可应用于字符型
• long 可应用于双精度型

• 类型限定符：

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

C++存储类

解释：

• 存储类定义 C++ 程序中变量/函数的范围（可见性）和生命周期，说明符放置在它们所修饰的类型之前
• 存储类
  • auto
  • register
  • static
  • extern
  • mutable
  • thread_local (C++11)
• 从 C++ 11 开始，auto 关键字不再是 C++ 存储类说明符，且 register 关键字被弃用。

auto 存储类：

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

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’ 并不意味着变量将被存储在寄存器中，它意味着变量可能存储在寄存器中，这取决于硬件和实现的限制。

{
  www.shyejk.com
}

static 存储类：

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

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

extern 存储类：

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

mutable 存储类：

thread_local 存储类：

• 只知道和线程有关，具体不清楚
• 使用 thread_local 说明符声明的变量仅可在它在其上创建的线程上访问。 变量在创建线程时创建，并在销毁线程时销毁。 每个线程都有其自己的变量副本。thread_local 说明符可以与 static 或 extern 合并。可以将 thread_local 仅应用于数据声明和定义，thread_local 不能用于函数声明或定义。

C++数组\字符串

数组

声明数组

• C++ 中要声明一个数组，需要指定元素的类型和元素的数量，如下所示：
  • type arrayName[arraySize];
  • double balance[10];

初始化数组

double balance[5] = {1000.0, 2.0, 3.4, 7.0, 50.0};
double balance[] = {1000.0, 2.0, 3.4, 7.0, 50.0};
balance[4] = 50.0;

C++字符串

• C++ 提供两种类型的字符串：
  • C 风格字符串
  • C++ 引入的string类型

C风格字符串

• 声明和初始化创建了一个 “Hello” 字符串。由于在数组的末尾存储了空字符，所以字符数组的大小比单词 “Hello” 的字符数多一个

  char greeting[6] = {'H', 'e', 'l', 'l', 'o', '\0'};
  char greeting[] = "www.veryxzx.com";
  

• C++ 中有大量的函数用来操作以 null 结尾的字符串

C++中的String类

• C++ 标准库提供了 string 类类型，支持上述所有的操作，另外还增加了其他更多的功能

  #include 
  #include 
  using namespace std;
  int main ()
  {
  string str1 = "Hello";
  string str2 = "World";
  string str3;
  int  len ;
  
  // 复制 str1 到 str3
  str3 = str1;
  cout << "str3 : " << str3 << endl;
  
  // 连接 str1 和 str2
  str3 = str1 + str2;
  cout << "str1 + str2 : " << str3 << endl;
  
  // 连接后，str3 的总长度
  len = str3.size();
  cout << "str3.size() :  " << len << endl;
  
  return 0;
  }
  

C++指针

什么是指针

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

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

C++中使用指针

• 使用指针是会频繁进行一下操作：
  • 定义一个指针变量
  • 把变量地址赋值给指针
  • 访问指针变量中可用地址的值

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

C++指针详解

C++引用

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

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

- & 读作引用
- 第一个声明可以读作 "r 是一个初始化为 i 的整型引用"
- 第二个声明可以读作 "s 是一个初始化为 d 的 double 型引用"

#include 

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;
	s -= 1;
	cout << "Value of d : " << d << endl;
	cout << "Value of d reference : " << s << endl;
	getchar();
	return 0;
}

• 输出：
  • Value of i : 5
  • Value of i reference : 5
  • Value of d : 10.7
  • Value of d reference : 10.7

C++日期&时间

C++基本的输入输出

I/O 库头文件

标准输出流(cout)

• 对象 cout 是 iostream 类的一个实

   char str[] = "Hello C++";
 
   cout << "Value of str is : " << str << endl;

• << 运算符被重载来输出内置类型（整型、浮点型、double 型、字符串和指针）的数据项
• 流插入运算符 << 在一个语句中可以多次使用
• endl 用于在行末添加一个换行符

标准输入流(cin)

• 对象 cin 是 iostream 类的一个实例
• cin 对象附属到标准输入设备，通常是键盘
• cin 是与流提取运算符 >> 结合使用

cin >> name;
cin >> name >> age;
//相当于
cin >> name;
cin >> age;

标准错误流（cerr）

• 预定义的对象 cerr 是 iostream 类的一个实例。cerr 对象附属到标准错误设备，通常也是显示屏，但是 cerr 对象是非缓冲的，且每个流插入到 cerr 都会立即输出。

cerr << "Error message : " << str << endl;

标准错误流（cerr）

• 预定义的对象 clog 是 iostream 类的一个实例。clog 对象附属到标准错误设备，通常也是显示屏，但是 clog 对象是缓冲的。这意味着每个流插入到 clog 都会先存储在缓冲在，直到缓冲填满或者缓冲区刷新时才会输出。

clog << "Error message : " << str << endl;

C++ 数据结构

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

定义结构

struct type_name {
member_type1 member_name1;
member_type2 member_name2;
member_type3 member_name3;
.
.
} object_names;
//例：
struct Books
{
   char  title[50];
   char  author[50];
   char  subject[100];
   int   book_id;
} book;

访问结构成员

• 为了访问结构的成员，我们使用成员访问运算符(.)。成员访问运算符是结构变量名称和我们要访问的结构成员之间的一个句号。

    #include 
    #include 
    
    using namespace std;
    
    // 声明一个结构体类型 Books 
    struct Books
    {
    char  title[50];
    char  author[50];
    char  subject[100];
    int   book_id;
    };
    
    int main( )
    {
    Books Book1;        // 定义结构体类型 Books 的变量 Book1
    Books Book2;        // 定义结构体类型 Books 的变量 Book2
    
    // Book1 详述
    strcpy( Book1.title, "C++ 教程");
    strcpy( Book1.author, "Runoob"); 
    strcpy( Book1.subject, "编程语言");
    Book1.book_id = 12345;
    
    // Book2 详述
    strcpy( Book2.title, "CSS 教程");
    strcpy( Book2.author, "Runoob");
    strcpy( Book2.subject, "前端技术");
    Book2.book_id = 12346;
    
    // 输出 Book1 信息
    cout << "第一本书标题 : " << Book1.title <