本贴为复习专用

基础篇

• C++ 完全支持面向对象的程序设计，包括面向对象开发的四大特性:（ 封装,抽象,继承,多态 ）
• 标准的 C++ 由三个重要部分组成：
  • （核心语言），提供了所有构件块，包括变量、数据类型和常量，
  • （C++ 标准库），提供了大量的函数，用于操作文件、字符串
  • （标准模板库（STL）），提供了大量的方法，用于操作数据结构

• IDE编程步骤

  • ①源代码:你手敲的代码

  • ②编译器:用来编译源代码, 相当于翻译,把你的C++语言C语言翻译给电脑听,即对电脑讲机器语言,当然也是代码,这里把翻译过的代码叫目标代码

  • ③目标代码:被编译器编译过的源代码

  • ④链接程序=启动代码+库代码+目标代码, 你的程序可能需要调用很多其他的代码来帮助你完成任务,所以需要把他们链接起来, 整合起来的代码就是可执行代码

  • ⑤可执行代码, 最终代码即程序运行时的代码

• 文本编辑器包括 （Windows Notepad）、（OS Edit command）、（Brief）、（Epsilon）、（EMACS） 和（ vim/vi）

  • 文本编辑器的名称和版本在不同的操作系统上可能会有所不同。例如，（Notepad ）通常用于 Windows 操作系统上，（vim/vi ）可用于 Windows 和 Linux/UNIX 操作系统上。

• C++ 程序的源文件通常使用扩展名（ .cpp、.cp 或 .c）, 大多数的 C++ 编译器并不在乎源文件的扩展名，但是如果您未指定扩展名，则默认使用 .cpp。

  扫描二维码关注公众号，回复： 12627983 查看本文章

• 写在源文件中的源代码是人类可读的源。它需要"编译"，转为机器语言，这样 CPU 可以按给定指令执行程序。

• C++ 编译器用于把源代码编译成最终的可执行程序。

• 最常用的免费可用的编译器是 GNU 的 C/C++ 编译器，

  • 如果您使用的是 Linux 或 UNIX，请在命令行使用下面的命令来检查您的系统上是否安装了 GCC：

  • 如果您使用的是 Mac OS X，最快捷的获取 GCC 的方法是从苹果的网站上下载 Xcode 开发环境，并按照安装说明进行安装。一旦安装上 Xcode，您就能使用 GNU 编译器。

  • 为了在 Windows 上安装 GCC，您需要安装 MinGW。为了安装 MinGW，请访问 MinGW 的主页 www.mingw.org，进入 MinGW 下载页面，下载最新版本的 MinGW 安装程序，命名格式为 MinGW-<version>.exe。</version>当安装 MinGW 时，您至少要安装 gcc-core、gcc-g++、binutils 和 MinGW runtime，但是一般情况下都会安装更多其他的项。添加您安装的 MinGW 的 bin 子目录到您的 PATH 环境变量中，这样您就可以在命令行中通过简单的名称来指定这些工具。当完成安装时，您可以从 Windows 命令行上运行 gcc、g++、ar、ranlib、dlltool 和其他一些 GNU 工具。

• C++的扩展名往往是.cpp 在linux中往往是.cxx,目标代码文件是.o 可执行文件是.out

• 类是一种规范, 描述了你设计的新型数据结构, 对象就是类的实现,即根据这种规范所构造的数据结构, 换句话说，类描述了：（一种数据类型的全部属性包括了可使用它执行的操作）, 而对象就是根据这些描述来创建的实体

• 函数可以来自函数库, 类也有类库,ostream和istream系列类就是一种类库,还有fstream系列类,类库不好听我们更喜欢叫系列类

• 预处理器

  • 什么是预处理器呢?在主编译之前对源文件进行处理,你不需要进行特殊的操作来调用,只需要#即可

  • 使用#Include编译指令,比如#include <iostream>就是把iostream文件添加到程序中,这是一种比较典型的预处理器操作,在源代码被编译之前,替换或添加文本

  • #include指令会吧iostream文件中的内容和源代码一起发送给编译器,具体就是iostream中的全部文件会取代#include <iostream>这一行代码,并且不修改源代码文件,而是新生成一个复合文件

• 头文件=包含文件

  • iostream这种文件叫包含文件(常常被include包含在其他文件中) ,也叫头文件(常常在程序起始处)

  • C++有很多头文件,每个头文件都带来了一组特定的工具

  • C的头文件往往是.h扩展名, C++往往是没有扩展名,使用C的头文件时,你需要（去掉.h且在名前加c即cmath=math.h）

  • C用不同扩展名表示不同文件类型,C++取消所有扩展名

  • 在应用程序中引用非标准库时,可以先去浏览一下这些包含文件,这是最好的文档信息,你可以掌握很多知识,这种行为是很好的习惯

• 名称空间

  • 上述头文件去掉了.h其实不是这么简单,而是让没有.h的头文件包含了名称空间

  • 名称空间编译指令using namespace <name>比如using namespace std; 这里是using编译指令

    • 打断一下,你现在了解了两个编译指令了,一个是using一个是#include

  • 头文件包含了名称空间, 名称空间包含了（所需要的类,函数,变量等的名字）,想访问他们有如下两种方式以std为例

    • using std::cout;   //通过using编译指令来声明了cout的来源是std名称空间

    • using namespace std; cout<<'a'<<endl;

• cout预定义的对象,它懂得如何显示字符串,数字和字符等数据

  • cout是个对象,那是哪个类的对象呢????

  • 插入运算符<<符号可以把信息流入到cout中即cout<<'a'

  • cout<<'a'就是把字符a从程序中流出去了, 而cout正是表示了这种输出流,cout对象的具体属性是在iostream头文件中定义的,属性包括了一个插入运算符<<, 可以把数据插入到输出流中

• 控制符endl,表示重启一行,如果把控制符endl也插入到输出流中,那你屏幕光标将会（直接跳到下一行的开头）,endl控制符也是iostream头文件中定义的,同样名字也在std名称空间中

  • cout代表了输出流,所以并不能移动光标

  • cout是指代表了输出流,所以也不能产生空格,如果你需要空格,那就把空格插入到输出流中吧

• C++程序可以看成一组函数, 而每个函数又是一组语句

• 声明语句创建了变量,作用就是:指出了（信息存储的具体位置）和（需要的内存空间大小）

  • (计算机存储数据时,必须要知道数据的存储位置和所占内存空间大小)

  • 声明语句提供了（存储类型）和（位置标签）,位置标签表示了具体位置,存储类型则代表了所占内存空间的大小信息

    • 比如int num; int是整数类型,根据计算机系统不同,整数类型所占的内存空间(位数或字节数)也不同,而num则代表了上述内存空间的位置标签,num作为变量是可以改变的,就是内存空间存储的信息是可以修改的

    • 不同的数据类型,则代表了不同的内存空间占用的大小数量

  • 你不需要管这些底层的事情,编译器会帮你分配好内存并标记好位置

• 定义和声明最好根据函数和变量来分别讨论

  • 对于变量而言：

    • 变量的声明，指出存储位置和所需空间大小

    • 变量的定义，指出存储位置和所需空间大小，且申请相应内存空间

  • 对于函数而言：

    • 函数的声明，相当于变量声明于变量，声明函数原型

    • 函数的定义，给出函数的结构体

思考：声明、定义、引用三者各什么意思？是否有什么联系？？

• 赋值语句,=赋值运算符则可以对内存空间中存储的数据进行修改

• 代表输入流的cin对象,插入运算符>>为cin提供了流入方向

• cout和cin都是智能对象,可以通过输入对象的类型而自动调整输入的数据类型

• 换行符\n, 换行符常用在字符串中,其实\n是一个字符,名称是换行符而已,

• 换行符\n和控制符endl的区别

  • 显然是字符数量少了\n两个endl四个

  • endl能够保证在程序继续运行前刷新屏幕，也就是立即显示在屏幕上,而\n不能, 甚至有时候你要在输入信息后才会有提示

  • 当然如果你只想要一个空行,两者都可以选择

    • cout<<endl;

    • cout<<"\n";

• 由于;标志着一条语句的结束, 所以你在一条语句中使用多少回车都是无法表示该语句的结束的,甚至是没有什么影响,所以在一条语句中,回车的作用=空格=制表符(多个空格)

  • 这并不意味着你可以随意使用多个空格或者回车, 无论是C还是C++你都不能把空格,制表符,回车,放到元素中(比如变量名), 也不能放到字符串中,这很重要,cout<<"字符串中不能添加回车,不要换行"

• 标记和空白

  • 一行代码中不可分割元素比如int 比如main等,都叫做标记,通常我们用空格制表符回车把两个标记分开({}就是用回车分开的)

  • 有些可以通过一个空格来分开,有些不可以,比如 int main()你不要把回车插入到int和main中间

语法篇

• C++ 程序可以定义为（对象）的集合，这些对象通过（调用）的方法进行交互。现在让我们简要地看一下什么是类、对象，方法、即时变量。
  • 对象 - 对象具有状态和行为。例如：一只狗的状态 - 颜色、名称、品种，行为 - 摇动、叫唤、吃。对象是类的实例。
  • 类 - 类可以定义为描述对象（行为,状态的模板）。
  • 方法 - 从基本上说，一个方法表示一种行为。一个类可以包含多个方法。可以在方法中写入逻辑、操作数据以及执行所有的动作。
  • 即时变量 - 每个对象都有其独特的即时变量。对象的状态是由这些即时变量的值创建的。
•  main() 是程序开始执行的地方

• 分号是语句结束符。也就是说，每个语句必须以分号结束。它表明一个逻辑实体的结束。

• C++ 标识符是用来标识变量、函数、类、模块，或任何其他用户自定义项目的名称。一个标识符以字母 A-Z 或 a-z 或下划线 _ 开始，后跟零个或多个字母、下划线和数字（0-9）。

• C++ 注释以 /* 开始，以 */ 终止。注释也能以 // 开始，直到行末为止。

• unsigned或signed改变范围不改变字节数, short 字节 *0.5, long字节*2,如short int 则字节为2, long int 字节为8

• 使用 （typedef） 为（一个已有的类型取）一个新的名字

• 使用 （sizeof()） 函数来获取各种数据类型的大小。

• 运算符sizeof返回类型或变量长度,单位是B字节

  • 对变量操作时, 无需加括号,即int a = 0 ; cout<<sizeof(a); 直接用cout<<sizeof a;即可

  • 对数据类型操作时,加括号,即cout<<sizeof(int); 

  • sizeof运算符直接指出了整个数组的长度(有多少个元素就有多长)

  • sizeof运算符对指针进行操作时,得到的是指针的长度,即使指针指向的是个数组

  • strlen()函数则返回可见字符的个数,不包括'\0'空字符

• 枚举

  • 枚举类型(enumeration)是C++中的一种派生数据类型，它是由用户定义的若干枚举常量的集合.如果一个变量只有几种可能的值，可以定义为枚举(enumeration)类型。所谓"枚举"是指将变量的值一一列举出来，变量的值只能在列举出来的值的范围内。

  • 创建枚举，需要使用关键字 enum。

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

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

  • 代码中是两种不同的创建枚举的方法,第一种方法,name, age,width,height的值,是其下标值,如age下表是1,则age=1;

  • 第二种方法,直接赋值,age就是18

  • 注意,枚举的各个元素都是符号常量,并且指定的具体数值必须是整数,当然第一种情况默认赋值必然是整数

/*
enum 枚举名{ 
     标识符[=整型常数], 
     标识符[=整型常数], 
... 
    标识符[=整型常数]
} 枚举变量;
*/

enum color { red, green, blue} c ;
c = blue;

enum color { red, green = 5, blue};

enum person {name, age, width, height};
enum person0 {name = 1, age = 18, width =120, height=133232};

变量

• 变量的名称可以由（字母、数字和下划线）字符组成。它必须以（字母或下划线）开头。大写字母和小写字母是不同的，因为 C++ 是大小写敏感的。

类型	描述
bool	存储值 true 或 false。
char	通常是一个字符（八位）。这是一个整数类型。
int	对机器而言，整数的最自然的大小。
float	单精度浮点值。单精度是这样的格式，1位符号，8位指数，23位小数。
double	双精度浮点值。双精度是1位符号，11位指数，52位小数。
void	表示类型的缺失。
wchar_t	宽字符类型。

使用（ extern 关键字）在任何地方声明一个变量

• 左值（lvalue）：指向内存位置的表达式被称为左值（lvalue）表达式。左值可以出现在赋值号的左边或右边。
• 右值（rvalue）：术语右值（rvalue）指的是存储在内存中某些地址的数值。右值是不能对其进行赋值的表达式，也就是说，右值可以出现在赋值号的右边，但不能出现在赋值号的左边。

• 强制类型转换(这里是简单地类型转换,还有更高级的操作在fstream类中)

  • static_cast<>运算符是强制类型转换符

  • static_cast<int> (xjh)把xjh变量强制转换成int类型

• 变量定义和变量声明（针对的是变量）
  • 声明(declaration):不分配内存。  而 定义:是在变量声明后，给它分配内存
    • 上边说的声明是说，指明了存储位置和所需的内存空间大小，并没有申请内存空间
  • 而函数,则需要定义前进行声明
  • 变量声明=提供名字+存储类型,
  • 变量定义=提供名字+存储类型+申请内存空间
  • extern外部声明

  • // 变量声明
    extern int a, b;
    extern int c;
    extern float f;
    
    // 函数声明
    int func();
    
    int main ()
    {
      // 变量定义
      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 ;
    
      // 函数调用
      int i = func();
     
      return 0;
    }
    
    
    
    // 函数定义
    int func()
    {
        return 0;
    }

常量

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

  • 使用 #define 预处理器。

    • 预处理编译指令#define这里举个例子来说明

      • #define INT_MAX 32767

      • 编译指令#define在编译前在程序中查找所有的INT_MAX，然后用32767替换。完成替换后，程序会被编译

      • 当然预处理器仅仅替换独立的标记，而不会替换嵌入INT_MAX的标记，如PINT_MAX或UINT_MAX

  • 使用 const 关键字。
    • 用const的优点：会进行类型安全检查。而define没有安全检查，且可能会产生意料不到的错误。

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

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

#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;
   
   const int NUMBER = 10;
   const float PRICE= 13.23;
   double output = NUMBER * PRICE;
   cout << output;
   return 0;
}

/*
212         // 合法的
215u        // 合法的
0xFeeL      // 合法的
078         // 非法的：8 不是八进制的数字
032UU       // 非法的：不能重复后缀
85         // 十进制
0213       // 八进制 
0x4b       // 十六进制 
30         // 整数 
30u        // 无符号整数 
30l        // 长整数 
30ul       // 无符号长整数
*/

• 浮点常量
  • 由整数部分、小数点、小数部分和指数部分组成。如3.14
    • 当使用小数形式表示时，必须包含整数部分、小数部分，或同时包含两者。
    • 当使用指数形式表示时， 必须包含小数点、指数，或同时包含两者。
    • 带符号的指数是用 e 或 E 引入的。

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

转义字符

引用 &

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

• 引用和指针的三个不同：

  • 不存在空引用。引用必须连接到一块合法的内存。（不存在空引用，存在空指针）

  • 一旦引用被初始化为一个对象，就不能被指向到另一个对象。指针可以在任何时候指向到另一个对象。（引用不可二次多次指向，指针可以）
  • 引用必须在创建时被初始化。指针可以在任何时间被初始化。
• 变量名称是变量附属在内存位置中的标签，可以把引用当成是变量附属在内存位置中的第二个标签,也就是说修改其一另一个值也会改变,因为对应的内存块的数值变了.

引用时要注意两个两个变量的类型要求保持一致,const引用const int类型将产生错误

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

• 在这些声明中，& 读作引用。因此，第一个声明可以读作 "r 是一个初始化为 i 的整型引用"，第二个声明可以读作 "s 是一个初始化为 d 的 double 型引用"。

存储类

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

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

可以使用STL中的 typeid(auto_name).name()来查看类型名

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

cout<<typeid(x1).name()<<endl;

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

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

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

  • 当 static 修饰全局变量时，会使变量的作用域限制在声明它的文件内。

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

• extern 存储类用于提供一个全局变量的引用，全局变量对所有的程序文件都是可见的。

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

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

//File0

#include <iostream>

int count ;
extern void write_extern();

int main()
{
   count = 5;
   write_extern();
}

//File1

#include <iostream>

extern int count;

void write_extern(void)
{
   std::cout << "Count is " << count << std::endl;
}

运算符

循环与判断

• 循环控制语句
  • break 终止 loop 或 switch 语句，程序流将继续执行紧接着 loop 或 switch 的下一条语句。
  • continue 引起循环跳过主体的剩余部分，立即重新开始测试条件.
• 判断语句(拿python笔记充数,逻辑是同样的)
  • 

• ? : 运算符 可以用来替代 if...else 语句。

Exp1 ? Exp2 : Exp3;

• 如果 Exp1 为真，则计算 Exp2 的值，结果即为整个表达式的值。如果 Exp1 为假，则计算 Exp3 的值

函数参数

• 如果函数要使用参数，则必须声明接受参数值的变量。这些变量称为函数的形式参数。

  形式参数就像函数内的其他局部变量，在进入函数时被创建，退出函数时被销毁。

  当调用函数时，有两种向函数传递参数的方式：

• 当您定义一个函数，您可以为参数列表中后边的每一个参数指定默认值。当调用函数时，如果实际参数的值留空，则使用这个默认值。

• C++ 内置了丰富的数学函数，可对各种数字进行运算。下表列出了 C++ 中一些有用的内置的数学函数。为了利用这些函数，您需要引用数学头文件

#include <iostream>
#include <cmath>
using namespace std;

int main ()
{
   // 数字定义
   short  s = 10;
   int    i = -1000;
   long   l = 100000;
   float  f = 230.47;
   double d = 200.374;

   // 数学运算
   cout << "sin(d) :" << sin(d) << endl;
   cout << "abs(i)  :" << abs(i) << endl;
   cout << "floor(d) :" << floor(d) << endl;
   cout << "sqrt(f) :" << sqrt(f) << endl;
   cout << "pow( d, 2) :" << pow(d, 2) << endl;

   return 0;
}

随机数

• 随机数生成器，有两个相关的函数。一个是 rand()，该函数只返回一个伪随机数。生成随机数之前必须先调用 srand() 函数。

• 下面是一个关于生成随机数的简单实例。实例中使用了 time() 函数来获取系统时间的秒数，通过调用 rand() 函数来生成随机数：注意需要包含的库文件

#include <iostream>
#include <ctime>
#include <cstdlib>

using namespace std;

int main ()
{
   int i,j;

   // 设置种子
   srand( (unsigned)time( NULL ) );

   /* 生成 10 个随机数 */
   for( i = 0; i < 10; i++ )
   {
      // 生成实际的随机数
      j= rand();
      cout <<"随机数： " << j << endl;
   }

   return 0;
}

数组

• C++ 支持数组数据结构，它可以存储一个固定大小的相同类型元素的顺序集合。

• 如何数组声明?

typeName arrayName[arraySize]; 

• 其中typeName是你元素类型, arrayName是你的自定义数组名,arraySize是你自定义数组长度(不能是变量必须是const)即元素总个数

• 举例说明数组的复合意义?float xjh[1228]; 这里的xjh类型不是数组,而是float数组, 要这么说:"你要建立一个int数组或者float数组"

• 数组从0开始索引并用[下标]来索引

• 数组赋值也不被允许,即int xjh[3] = {1,2,2,8};int xjh1[3] = {1,2,2,8};xjh1 = xjh;这种操作不被允许,只能通过下标访问元素来对某个元素进行赋值,修改等

• 所有的数组都是由连续的内存位置组成。最低的地址对应第一个元素，最高的地址对应最后一个元素。

• 声明数组，需要指定元素的类型和元素的数量，type arrayName [ arraySize ];

  • 这叫做一维数组。arraySize 必须是一个大于零的整数常量，type 可以是任意有效的 C++ 数据类型。

• 初始化数组

  • 可以逐个初始化数组，也可以使用一个初始化语句

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

    快速初始化,举例如int数组 int xjh[3] = {1,2,2,8}; 即利用{}来对元素对位初始化

    • 注意{}只能在初始化时使用,若int xjh[3]; 然后再xjh[3] = {1,2,2,8};则不被允许

• 数组元素可以通过数组名称加索引进行访问。元素的索引是放在方括号内，跟在数组名称的后边。

• 数组赋值,只能元素对元素,不能数组名对数组名,如下操作是非法的

  int array[3] = {1,2,3};
  int array1 = array;

字符串

基于数组的字符串即C-style stringC⻛格字符串 

• 字符串实际上是使用 null 字符 '\0' 终止的一维字符数组。因此，一个以 null 结尾的字符串，包含了组成字符串的字符。

• char greeting[6] = {'H', 'e', 'l', 'l', 'o', '\0'};
  char greeting[] = "Hello";
  //上述两个语句是一样的效果

  

• 'S'是字符常量,相当于83的另一个写法
• "S"是字符串,字符串"S"双引号表示,他是两个字符,即'S'和'\0',而且,"S"表示的其实是字符串所在的内存地址(地址在C++中是一个独立类型,你要用这种眼光去审视地址)
• istream中的类cin提供了面向行的类成员函数getline()和get()
  • getline()从输入队列中读取输入内容, 遇到换行符停止读取,同时将换行符丢弃
    • getline(name,20) 读取19个元素和一个换行符
  • get()从输入队列中读取输入内容,遇到换行符停止读取,同时将换行符返还给输入队列
    • 如果想提出换行符,可以利用空参数的cin.get(),它可以读取任何字符,用它来处理换行符,为下一行做准备

注意区分cin.getline()和getline(),前者是类方法,后者是函数

• 字符串输入,cin对象的解释

  • cin对象通过使用空白,即空格,制表符(多个空格)换行符, 来确定字符串的结束位置, 这说明cin对象在输入流中每次只读取一个单词, 读取单词后就把它放到数组中并自动添加空字符

基于string类库的字符串

• 首先你要包含string类库文件(头文件), string类的名称在标准名称空间std中,std::string即可完成引用

• String类的对象来存储字符串,String类的设计让程序可以自动处理字符串的大小

• 数组不能赋值,但是String类对象可以,string s1;string s2; s1=s2;是允许的

• 还可以通过+来进行拼接合并,这里是无缝合并

• 通过类方法.size()可以快速获得String类对象的长度

C++ 日期 & 时间

• C++ 标准库没有提供所谓的日期类型。C++ 标准库没有提供所谓的日期类型。需要在 C++ 程序中引用 <ctime> 头文件。