01-开始

程序骨架

// date:2017-7-18
/*
    每一个 C++ 程序包含一个或多个函数，其中必须有一个 main 函数。操作系统通过调用 main
    函数来运行 C++ 程序。

    函数的定义有四个元素：返回类型、函数名字、参数列表和函数体。

    main 函数要求有一个 int 的返回类型，int 类型代表整数。int 类型是内置类型（built-in type）

    编译这个程序：
    1. g++ simple_pro.cpp -o simple_pro
    2. a.exe
*/

int main(){
    // return 语句结束函数，return 语句也可以给函数的调用者返回一个值
    // 在这里例子中，main 函数给操作系统返回了一个 0, 0 是一个整数，是 int 类型。
    // 类型是一个重要的概念，类型定义了数据元素的内容和可以对其进行的操作。程序操作的数据
    // 存储在变量中，每一个变量都一个一个类型。如果一个叫 v 的变量的类型是 T，我们就说 v 的类型是 T
    // 在大多数操作系统中，main 函数的返回值是一个状态标志，0 标志者程序正常退出；
    // 非 0（通常是-1） 表示程序异常退出。我们可以在运行完一个程序后打印出这个返回值：
    // 1. 在 Unix-like 中，$ echo $?
    // 2. 在 Windows 中，$ echo %ERRORLEVEL%
    return -1;  // 分号是结束一条语句的标志
}

输入和输出

// date:2017-7-18

// 告诉编译器，我们要使用 iostream 库
// 任何使用库功能的程序必须包含其关联的头文件
#include<iostream>
/*
    C++ 没有提供操作 IO 的语句，但是它提供了大量的标准库可以进行 IO 的操作。我们需要知道的一个重要的库是 iostream. 
这个库有两个类型，一个是 istream，一个是 ostream，分别代表输入流和输出流。
流是从IO 设备读入或者写出的字符序列。流形象滴表达出了字符是随时间的流逝而产生或者消耗的。

    iostream 库定义了四个 IO 对象：
    1. cin 是一个 istream 对象，用来处理输入，它也叫做标准输入；
    2. cout 是一个 ostream 对象，也叫做标准输出，它用来处理输出；
    3. cerr 是一个 ostream 对象，也叫标准错误流，用来输出警告和错误信息
    4. clog 是一个 ostream 对象，用来输出一般的程序执行信息

    通常，程序将这些对象关联到运行程序的窗口中。因此，当从 cin 中读取数据中，数据来自运行程序的窗口；
    当我们将信息写出到 cout、cerr 和 clog 时，也会显示在这个窗口中。

    前缀 std:: 表示名字 cin、cout 被定义在名为 std 的命名空间中。名称空间避免了我们定义的名字
    和一个库中的名字之间的冲突。所有标准库定义的名字在名称空间 std 中。:: 称为作用域操作符
*/

int main(){
    // 下面的语句是一个表达式，表达式产生一个结果并且由多个操作数和操作符组成。
    // << 是输出操作符，有两个操作对象，左边的操作对象必须是 ostream 对象；右面
    // 的操作对象是一个将被打印的值。这个操作将右面的值写到左边的 ostream 对象。这个
    // 操作的返回值是左边的对象。
    // std::endl 叫操作符，是一个特殊的值。将它写出到 ostream 会导致换行和
    // 刷新与设备关联的 buffer。刷新缓存确保程序产生的输出会被写到输出流而不是在内存中
    // 等待输出。
    std::cout << "Enter two numbers:" << std::endl;
    // 声明变量并赋值（初始化）。初始化后变量才创建了
    int v1 = 0, v2 = 0;
    // >> 是输入操作符，它的左操作对象是 istream 并且右操作对象是一个变量，它从 istream 中
    // 读取数据存储到变量中并且返回左操作对象 istream
    std::cin >> v1 >> v2;
    // 如下所示，<< 的操作对象有多种类型，字符串、int 类型，甚至表达式 v1 + v2
    // 库定义了输入和输出操作的不同版本来处理不同的类型
    std::cout << "The sum of " << v1 << " and " << v2
                << " is " << v1 + v2 << std::endl;
    return 0;
}

流程控制

while 循环

下面的程序使用 while 循环演示了从 1 加到 10 的和是多少。

// date:2017-7-18
#include <iostream>

int main()
{
    int sum = 0, value = 1;
    // keep excuting the while as long as val is less than or equal to 10
    while (value <= 10){
        sum += value; // assigns sum + value to sum
        ++value; // add 1 to value
    }

    std::cout << "Sum fo 1 to 10 inclusive is " << sum << std::endl;
    return 0;
}

for 循环

下面的程序使用 for 循环计算从 1 加到 10 的和是多少。

// date:2017-7-18
#include <iostream>

int main()
{
    int sum = 0;
    // sum valuess from 1 through 10 inclusive
    for (int val = 1; val <= 10; ++val){
        sum += value; // equivalent sum = sum + val
    }
    std::cout << "Sum of 1 to 10 inclusive is " << sum << std::endl;
    return 0;
}

if 语句

下面的程序统计了一串数字中连续出现的整数的次数。如果输入： 42 42 42 42 55 55 62 1000 1000 1000，那么程序会输出：

42 occurs 4 times
55 occurs 2 times
62 occurs 1 times
1000 occurs 3 times

相同的整数必须连续出现，这个程序才正确执行。

//date:2017-7-18

#include <iostream>

int main()
{
    // currVal is the number we're counting; we'll read new values into val
    int currVal = 0, val = 0;
    // read first number and ensure that we have data to process
    if (std::cin >> currVal){
        int cnt = 1; // store the count for the current value we're processing
        while (std::cin >> val){ // read the remaining numbers
            if (val == currVal){ // if the values are the same
                ++cnt;  // add 1 to cnt
            }else{ // otherwise, print the count for the previous value
                std::cout << currVal << " occurs " << cnt << " times " << std::endl;
                currVal = val;  // remember the new value
                cnt = 1;  // reset the counter
            }

        }
        std::cout << currVal << " occurs " << cintnt << " times " << std::endl;
    }
    return 0;
}

Note:

When we use an istream as a condition, the effect is to test the state of the stream. If the stream is valid---that is, if the stream hasn't encountered an error---then the test succeeds. An istream becomes invalid when we hit End-Of-File or encounter an invalid input, such as reading a value that is not an integer into a variable had the int type. An istream that is in an invalid state will cause the condition to yield false. To input End-Of-File:

On Window, hold Ctrl and hit z, then press Enter

On UNIX, Linux or Mac, hold Ctrl and hit d

Terms

参数（argument）

被传递给函数的值。（Value passed to a function）

赋值（assignment）

抹去一个对象的当前值，然后用新的值替换。（Obliterates an object's current value and replaces that value by a new one.）

块（block）

0个或者多个花括号括起来的语句的序列。（Sequence of zero or more statements enclosed in curly braces.）

缓冲区（buffer）

一个用来保存数据的存储区域。IO 设备经常在缓冲区中存储输入（或者输出），并且按程序指令分别从缓冲区中读取或写入数据。输出缓冲区可以显式地刷新以强制将缓冲区中的内容写出。默认情况下，从 cin 中读取将刷新 cout；当程序结束的时候，cout通常也能被刷新。（A region of storage used to hold data. IO facilities often store input (or output) in buffer and read or write the buffer independently from actions in the program. Output buffers can be explicitly flushed to force the buffer to be written. By default, reading cin flushes cout; cout is also flushed when the program ends normally.）

内置类型（built-in type）

C++ 语言定义的类型，例如 int. （Type, such as int, defined by the language.）

cerr

被关联到标准错误流的 ostream 对象，这个对象通常和标准输出的设置是一样的。默认情况下，写到 cerr 的数据是不被缓存的。通常将错误信息和其他不是程序正常逻辑的的数据写入 cerr。（ostream object tied to the standard error, which often writes to the same device as the standard output. By default, writes to cerr are not buffered. Usually used for error message or other output that is not part of the normal logic of the program.）

字符串字面量（string literal）

被双引号括起来的字符序列。（Sequence of character enclosed by double quote.）

cin

用来从标准输如读取数据的 istream 对象。（istream object used to read from the standard input）

类（class）

用来定义我们自己的数据结构以及与其相关联的操作的工具。类是C++中最基础的特征之一。库提供的类型，例如 istream 和 ostream 都是类。（Facility for defining our own data structures together with associated operators. The class is on of the most fundamental features in C++. Library types, such as istream and ostream, are classes.）

类类型（class type）

一个使用 class 定义的类型。这个类型的名字是类的名字。（A type defined by a class. The name of the type is the class name.）

clog

被绑定到标准错误的ostream 对象。默认情况下，向 clog 写数据是被缓冲的。clog 通常用来写数据到一个 log 文件中，来报告程序执行的信息。（ostream object tied to the standard error. By default, writes to clog are buffered. Usually used to report information about program executing to a log file.）

注释（comments）

在程序源文件中被编译器忽略的文本。C++有两种注释：单行和块注释。单行注释以 // 开始，然后在 // 后的文本（一直到行结束）都是注释。块注释以 /* 开始，以*/ 结束，其间的文本是注释。

条件（condition）

一个结果是true或者false的表达式。0是false，非0是true。（An expression that is evaluated as true or false. A value of zero is false; any other value yield true.）

cout

用来向标准输出写数据的 ostream 对象。通常用来写程序的输出。（ostream object used to write to the standard output. Ordinarily used to write the output of a program）

花括号（curly brace）

花括号用来定义块。左花括号 { 定义块的开始，右花括号 } 定义块的结束。（Curly braces delimit blocks. An open curly ({) starts a block; a close curly (}) ends one）

数据结构（data structure）

一个数据以及这个数据可以进行的操作的逻辑组。（A logical grouping of data and operators on that data.）

编辑-编译-调试（edit-compile-debug）

让一个程序正确执行的过程。（The process of getting a program to execute properly.）

文件结束end-of-file

系统识别的标记，这个标记暗示着一个文件没有了更多的输入。（System-specific marker that indicates that there is no more input in a file.）

表达式（expression）

最小的计算单元。一个表达式通常由一个或者多个操作对象、一个或多个操作符组成。表达式能被计算出一个值。例如，架设 i 和 j 是 int 类型，那么 i + j 是一个表达式，它们的值是这两个 int 类型数据的和。（The smallest unit of computation. An expression consists of one or more operands and usually one or more operators. Expressions are evaluated to produce a result. For example, assuming i and j are ints, then i + j is an expression and yields the sum of the two int values.）

for 语句（for statement）

提供了迭代执行的迭代语句。通常用来重复执行已知次数的计算。（Iteration statement that provides iterative execution. Often used to repeat a calculation a fixed number of times.）

函数（function）

命名了的计算单元。（Named unit of computation.）

函数体（function body）

定义了一个被函数执行的动作的块。（Block that defines the actions performed by a function.）

头文件（header）

这是一种机制。通过这种机制，我们可以定义一个类或者其他名字，然后在多个程序中使用。使用头文件的程序通过 #include 指令引入头文件。（Mechanism whereby the definitions of a class or other names are made available to multiple programs. A grogram uses a header through a #include directive.）

if 语句（if statement）

根据一个指定的条件的值，有条件的执行。如果条件是true，那么 if 体被执行。否则，else 块被执行（如果有的话）。（Conditional execution based on the value of a specified condition. If the condition is true, the if body is execute. If not, the else body is executed if there is one.）

初始化（initialize）

在一个对象被创建的时候，给它一个值。（Give an object a value at the same time that it is created.）

iostream

这是一个头文件，提供了库类型来进行面向流的输入和输出。（Header that provides the library type for stream-oriented input and output.）

istream

这是 iostream 头文件提供的一种类型，支持面向流的输入。（Library type providing stream-oriented input.）

库类型（library type）

标准库定义的类型，例如 istream. （Type, such as istream, defined by the standard library.）

main

被操作系统调用来执行C++程序的函数。没一个程序必须有一个并且只能有一个叫做 main 的函数。（Function called by the operating system to execute a C++ program. Each program must have one and only one function named main.）

操作符（manipulator）

在读或写时，操作流本身的对象，例如 std::endl（写出这个对象会使得输出流被刷新）。（Object, such as std::endl, that when read or written "manipulates" the stream itself.）

成员函数（member function）

被一个类定义的操作。成员函数通常被调用来处理特定的对象。（Operation defined by a class. Member functions ordinarily are called to operate on a specific object.）

方法（method）

成员函数的同义词。（Synonym for member function.）

名称空间（namespace）

这是一种将库定义的名字放在一个单独的地方的机制。命名空间能避免无意的名字冲突。C++库定义的名字在名称空间 std 中。（Mechanism for putting names defined by a library into a single place. Namespaces help avoid inadvertent name clashes. The names defined by the C++ library are in the namespace std）

ostream

用来支持面向流的输出的库类型。（Library type providing stream-oriented output.）

参数列表（parameter list）

一个函数定义的组成部分。可以是空的，它指明了可以使用什么样的参数来调用这个函数。（Part of the definition of a function. Possibly empty list that specifies what arguments can be used to call the function.）

返回类型（return type）

被一个函数返回的值的类型。（Type of the value returned by a function.）

源文件（source file）

用来描述包含C++程序的文件的术语。（Term used to describe a file that contains a C++ program.）

标准错误（standard error）

用来报告错误的输出流。通常，标准输出和标准错误被绑定到执行程序的窗口。（Output stream used for error reporting. Ordinarily, the standard output and the standard error are tied to the window in which the program is executed.）

标准输入（standard input）

被绑定到程序执行的窗口的输入流。（Input stream usually associated with the window in which the program executes.）

标准库（standard library）

每个C++编译器必须支持的类型和函数的集合。标准库提供了支持 IO 的类型。（Collection of types and functions that every C++ compiler must support. The library provides the types that support IO.）

标准输出（standard output）

被绑定到程序执行窗口的输出流。（Output stream usually associated with the window in which the program executes.）

语句（statement）

语句是程序的组成部分，它表明了当程序执行时会发生的动作。以一个分号结束的表达式是一个语句；其他类型的语句包含块、if、for 和 while 语句，这些语句又可以包含其他的语句在它们的里面。

std

标准库使用的名称空间。std::cout 指出了我们正在使用的名字 cout 在 std 名称空间中被定义。（Name of the namespace used by the standard library. std::cout indicates that we're using the name cout defined in the std namespace.）

没有初始化的变量

没有给一个初始值的变量。没有指定初始化值的类变量被类初始化为特定的值。函数中定义的内置类型的变量除非显式初始化，否则没有被初始化。尝试使用一个未初始化的变量是一个错误。没有初始化的变量是bug的源头。（Variable that is not given an initial value. Variable of class type for which no initial value is specified are initialized as specified by the class definition. Variable of built-in type defined inside a function are uninitialized unless explicitly initialized. It is an error to try to use the value of an uninitialized variable. Uninitialized variables are a rich source of bugs.）

变量（variable）

一个被命名的对象。（A named object.）

while 语句（while statement）

重复语句，只要给定的条件为真，就一直执行。根据条件的真假，while 体被执行一次或者多次。（Iteration statement that provides iterative execution so long as a specified condition is true. The body is executed zero or more times, depending on the truth value of the condition.）

()操作符（() operator）

调用操作符。一对圆括号紧跟一个函数名字。这个操作符导致函数被调用。调用函数的参数可以放在圆括号的里面。（Call operator. A pair of parentheses "()" following a function name. The operator causes function to be invoked. Arguments to the function may be passed inside the parentheses.）

++操作符（++ operator）

自增操作符。让被操作对象的值加1；++i 和 i = i + 1 是一样的意思。（Increment operator. Adds 1 to the operand; ++i is equivalent to i = i + 1.）

+=操作符（+= operator）

复合赋值操作符，将右边的操作对象的值和左边的操作对象的值相加并存储到左边的操作对象中。a += b 和 a = a + b 有相同的功能。（Compound assignment operator that adds the right-hand operand to the left and stores the result in the left-hand operand; a += b is equivalent to a = a + b.）

. 操作符（. operator）

点号操作符，左边的操作对象必须是一个类类型的对象，右边的操作符必须是这个对象的成员的名字。这个操作符的结果是给定对象的成员。（Dot operator. Left-hand operand must be an object of class type and the right-hand operand must be the name of a member of that object. The operator yields the named member of the given object.）

:: 操作符（:: operator）

域操作符。在其他用途上，域操作符用来访问名称空间中的名字。例如 std::cout 表示名字 cout 来自于名称空间 std。（Scope operator. Among other uses, the scope operator is used to access name in a namespace. For example, std::cout denotes the name cout from the namespace std.）

=操作符（= operator）

将右边操作对象的值赋给左边操作对象指示的对象。（Assigns the value of the right-hand operand to the object denoted by the left-hand operand.）

-- 操作符（-- operator）

递减操作符。从操作对象的值中减去1；--i 和 i = i - 1 是同样的意思。（Decrement operator. Subtracts 1 from the operand; --i is equivalent to i = i - 1.）

<< 操作符（<< operator）

输出操作符。将右面的操作对象写到左边操作对象指示的输出流中：cout << "hi" 将 hi 写到标准输出中。输出操作能被连在一起：cout << "hi" << "bye" 将写出 hibye.（Output operator. Writes the right-hand operand to the output stream indicated by the left-hand operand: cout << "hi" writes hi to the standard output. Output operations can be chained together: cout << "hi" << "bye" write hibye.）

>> 操作符（>> operator）

输入操作符。从左边操作对象指示的输入流中读取数据存储到右面的操作对象中：cin >> i 读取标准输入流中的值存储在 i 中。输入操作能被连在一起：cin >> i >> j 读取第一个数据存储在 i 中，下一个数据存储在 j 中。（Input operator. Reads from the input stream specified by the left-hand operand into the right-hand operand: cin >> i reads the next value on the standard input into i. Input operations can be chained together: cin >> i >> j reads first into i and then into j.）

#include

使得一个文件中的代码在程序中可用的指令。（Directive that makes code in a header available to a program.）

==操作符（== operator）

相等操作符。测试左边的操作对象和右边的操作对象是否相等。（The equality operator. Tests whether the left-hand operand is equal to the right-hand operand.）

!=操作符（!= operator）

不等操作符。测试左边的操作对象是否和右面的操作对象不等。（The inequality operator. Tests whether the left-hand operator is not equal to the right-hand operand.）

<=操作符（<= operator）

小于等于操作符。测试左边的操作对象是否小于或者等于右边的操作对象。（The less-than-or equal operator. Tests whether the left-hand operand is less than or equal to the right-hand operand.）

<操作符（< operator）

小于操作符。测试左边的操作对象是否小于右边的操作对象。（The less-than operator. Tests whether the left-hand operand is less than the right-hand operand.）

>=操作符（>= operator）

大于等于操作符。测试左边的操作对象是否大于或者等于右边的操作对象。（Greater-than-or-equal operator. Tests whether the left-hand operand is greater than or equal to the right-hand operand.）

>操作符（> operator）

大于操作符。测试左边的操作对象是否大于右边的操作对象。（Greater than operator. Tests whether the left-hand operand is greater than the right-hand operand.）