C++ Primer 5th 读书会（第一周）

Chapter 1 Getting Start

gump(915537522)10:05:24

The GNU complier,version 4.7.0

这是C++ Primer采用的编译器。

也就是g++。

编程的时候也可以用最新的MS 的编译器。

第一章的内容比较基础，主要照顾刚入门的。

作者从一个问题入手引出C++的基本概念。

 

接下来，讲如何设计程序。

设计首先应当抛弃语言细节。

真正的问题——弄清楚我们需要去计算什么，怎样将问题分解为一组可以控制的部分，

如何对这样的部分开展工作。

这在名著《C++编程思想》中也有类似的描述：

面向对象的方法为程序员提供了在问题空间中表示各种事物元素的工具，从而向前迈

进了一大步。这种表示方法是通用的，并不限定程序员只能处理特定类型的问题。

我们把问题空间中的事物和它们在解空间中的表示称为“对象”（还有另外一些对象）。

总之，首先要弄清楚问题。

回到我们的问题

Ø Define variables

Ø Do input and output

Ø Use a data structure to hold the data

Ø Test whether two records have the same ISBN

Ø Contain a loop that will process every record in the transaction file

定义变量

做好输入输出工作

使用数据结构来保存数据

1.1 Writing a Simple C++ Program

gump(915537522)10:15:51

C++程序从一个叫main的函数开始。

int main()

{

    return 0;

}

这里需要注意一下。

有很多书都写void main()

包括谭浩强的那本。

标准的C++，必须返回int(或者省略不写，默认也是int)

这其实是错误的。

因为只有标准的C++才具有可移植性。

On most systems, the value returned from main is a status indicator. A return value of 0

 indicates success. A nonzero return has a meaning that is defined by the system. 

这个整数是返回给操作系统的。

0表示成功，其他整数表示不同类型的错误。

Ordinarily a nonzero return indicates what kind of error occurred.

半城思念半城凉<[e-mail]>10:21:19

返回错误的常见的有？

gump(915537522)10:21:56

嗯。一般这种情况很少发生。

学渣<[e-mail]>10:22:16

我就问一下，return 0是不是类似于调试？   

gump(915537522)10:22:17

具体的错误要看操作系统了。

独有的回忆<[e-mail]>10:22:24

最常见的我就知道一个段错误

gump(915537522)10:23:33

因为main也是一个函数，他成不成功需要向OS报告

忘川小憩(845052991)10:24:04

能讲一讲main函数参数的意义吗

gump(915537522)10:24:52

它有两个参数

前者表示命令行参数的个数。

后者表示一个字符串数组。即一个数组，这个数组里放的就是你敲入的命令行参数。

我举个例子

在命令行下，敲入./a.out  xx

int main(int argc,char *[]argv);

这应该是带参数的形式。

假设a.out表示我们的程序的可执行文件。

xx是程序可能需要的参数。

那么argc=2

argv[0]="./out"    argv[1]="xx"

上面的参数问题没有问题了吧。

 

wzq(793859693)10:29:58

int main(int argc,char * argv[]) 

应该是这样吧

半城思念半城凉<[e-mail]>10:30:12

可执行文件也是参数？

wzq(793859693)10:30:12

那样也行么？

gump(915537522)10:30:35

可执行文件也是参数。

gump(915537522)10:39:20

下面讲类型。

类型到底是什么？

为什么要定义类型这个概念。

类型既定义了数据元素的内容也定义了在这些数据上的操作。

A type defines both the contents of a data element and the operations that are possible

 on those data.

后面会讲其在内存中的表示。因为第一章只是一个总览。

Compiling and Executing Our Program

这个就不说了。

要么Linux下或win下编译。

$ g++ -o pro1 pro1.cc

编译C++ 的基本命令。

-o 表示输出(output)

意思就是编译prog1.cc   输出可执行文件prog1

g++ prog1.c -o prog1  也可以这样写。

you may need to specify -std=c++0xto turn on C++ 11 support.)

这是开启支持C++ 11的命令。

C:\Users\me\Programs> c1 /EHsc prog1.cpp

微软平台上。

1.2 A First Look at Input/Output

gump(915537522)10:42:01

下面讲输入输出的基本概念。

C++的基本输入输出是包含在库中，不是语言中的。

先讲iostream库

基础的iostream库有两个类型istream和ostream。

分别对应输入流和输出流。

那么什么是流。

直接从“流”的中文含义来理解。

流来流去....

说的是字符序列

流向IO设备。

The term streamis intended to suggest that the characters
are generated, or consumed, sequentially over time.

字符的产生，消耗，是随着时间顺序的进行的。

这就是流的概念。

 

Standard Input and Output Objeects

下面讲标准输入和输出对象。

对象是类型的一个具体的模版。

The library defines four IO objects

下面介绍这四种对象。

刚才说的istream和ostream是一个类。

cin是一个对象。

类型是istream

发音(see-in)

即标准输出

自然输出对象就是cout

类型是ostream

为什么我们能直接用cin, cout，因为这在标准库iostream里已经定义。

后面会讲到具体的iostream结构。

这讲在STL中讲。先简单了解一下。

另外还有两个ostream对象

cerr和clog

分别表示标准错误和标准日志

都是输出。

We typically use cerr, referred to as the standard error, for warning and error messages

 and clog for general information about the execution of the program.

clog保存了可执行程序的一些信息。

日志大家应该明白。

一般来说，系统会对每个程序执行时的对象关联一个窗口。

cout对应屏幕。

cin对应键盘。

cerr和clog和cout一样。

 

A Program That Uses the IO Library

cout<<x

现在流的概念就显示出现了。

x从高流向cout

即x流向了屏幕设备，于是你就在屏幕上看见了x的值。

cin>>x，从cin流向x，即从键盘获取字符到x。

#include <iostream>

int main()

{

    std::cout<<”enter two numbers:”<<std::endl;

int v1=0,v2=0;

std::cin>>v1>>v2;

std::cout<<”The sum of”<<v1<<” and ”<<v2

<<” is ”<<v1+v2<<std::endl’

} 

基本的程序，就不说了。

#include指令

In general, #include directives must appear outside ant function.

 

Writing to a Stream

这个刚才已经讲过 了。

向流写数据。

endl是控制符

manipulator 

翻译成操纵符也行

Writing endl has the effect of ending the current line and flushing the buffer

associated with that device. Flushing the buffer ensures that all the output the

program has generated so far is actually written to the output stream, rather

than sitting in memory waiting to be written.

endl要注意一下。

除了换行还有刷新缓冲区的作用。

Warning

Programmers often add print statements during debugging. Such statements

should always flush the stream. Otherwise, if the program crashes, output

may be left in the buffer, leading to incorrect inferences about where the

program crashed.

这是讲使用endl调试程序有好处。

注意下就行了。

 

gump(915537522)10:56:36

 

下面讲标准库的名字。

名字空间的概念。

为什么要用名字空间。

简单来说名字空间是为了解决名字不够用的问题。

但事实上不可能完全解决。只能是一定程度上解决。

只是限定了范围。就不需要解释了吧。都明白的。

std::cout基本语法

 

深圳-工作-流岚<[e-mail]>11:09:43

using namespace

半城思念半城凉<[e-mail]>11:10:06

这个我发现书上很少用

gump(915537522)11:10:23

一般最后不要使用using namespace std;

你想，本来我们的目的是为了解决名字不够用。如果你这样，相当于又把所有名字空间都

打开了

using std::cout；一般这样用。

1.3 A Word about Comments

gump(915537522)11:11:46

这是注释

没什么好讲的

using std::cout;
using std::endl;

注意的就是/**/不能嵌套就行。

/*

*Simple main function:

*Read two numbers and write their sum

*/

这是C++ Primer推荐的多行注释法。

每个*代表一行。

Comment pairs do not nest

这就是说不要嵌套

As a result, one comment pair
cannot appear inside another. 

1.4 Flow of Control

gump(915537522)11:15:07

控制流

while, for do while等，不说了。

while (std::cin >> value)

sum +=value;          //equivalent to sum=sum+ length

讲一下这个。

std::cin>>value  的返回值类型是std::cin.

相当于判断std::cin的真假。

怎么判断呢？

流是valid时，就是说遇到了错误。这时候就是FALSE

invalid

错误有这样：遇到换行符或者错误的输入。

比如说你本来要读一个int到cin，但是却遇到了not an integer时

嗯。返回类型就是istream，返回值是std::cin

下面讲编译程序时常出现的错误类型。

没什么好讲的。主要有语法错误，类型错误，声明错误。

值得注意的是，调试程序的时候错误会指定在某行，但错误会发生在附近

不一定是在该行。

基本的语句就不说了，if等等。

1.5 Introducing Classes

gump(915537522)11:24:35

类要解决三个问题。

类的名字，在哪定义，支持什么操作。

简单来说类就是 一组相似的东西的组合。

类一般定义在头文件里。

一般类名和头文件名字一样

比如说这里：类名是Sales_item,

头文件名字是Sales_item.h

这是一种规范。

头文件后面会深入。这里做个了解

下面介绍下文件重定向。

刚才我们说了，cout<<x表示x输出到屏幕。

可把这个屏幕换成文件，

Scorpio<[e-mail]>11:28:06

打断一下，在头文件里应该叫申明吧

gump(915537522)11:28:09

其实屏幕是一种设备，也是一种设备文件。

嗯。声明。说错了。谢谢。

addItems<infile>outfile

比如说这个重定向。

addItems

可执行文件名字。

它的输入是infile

输出是outfile

这是在linux下可以干的。

是在OS下。

在语言中也可以操作。

gump(915537522)11:32:28

上午到这里，下午在具体讲下语言中的文件重定向。然后从成员函数开始。

gump(915537522)14:03:54

成员函数

类里面的函数，也叫方法。是对象的行为表现。

item1.isbn()

这是基本语法。

Chapter 2 Variables and Basic Types

第二章主要讲变量和基本类型。

gump(915537522)14:06:41

主要内容。

涉及内建类型，变量，复合类型，const限定符。

先讲类型，它包含2个方面，分别是数据的含义，和能对数据进行什么操作。

举个例子，int x;x是一个整数，它的操作只能是针对整型的。你不能对它进

行间接访问符*操作。

C++的类型，一种是语言内建的，一种是你自己构造的。

2.1 Primitive Built-in Types

gump(915537522)14:11:45

arithmetic types and void. 

这些类型不需要记。我快速的过一遍。

需要注意的地方，会分析一下。

arithmetic types，有字符，整数，布尔，浮点

void也是一种类型。没有值，可以用在函数的返回值

 

独有的回忆<[e-mail]>14:13:44

和指针

gump(915537522)14:14:45

gump(915537522)14:14:59

标准规定了每一种类型的最小尺寸。

其实现根据具体的平台规定。但是一般都是一样的。

这三个是用来解决unicode character的。

简单解释下unicode

由于计算机的标准最早是由美国人制定的。

它们用的是ASCII码来解释字符。

但是中文啊，日文啊，韩文啊都没有。

为了兼容这些字符，提出了Unicode。

比如说一个汉字一般是2个字节。一个ASCII码是一个字节。

 

code god(717702609)14:18:44

utf8和unicode有什么关系

utf16、utf32

gump(915537522)14:19:06

utf是中文编码。

unicode的目的是希望把全世界的文字都包含进去。

Scorpio<[e-mail]>14:19:49

当初是因为能表示的字符不够用了

gump(915537522)14:19:59

对的。下面说char类型。

Scorpio<[e-mail]>14:20:03

才加了unicode

gump(915537522)14:20:37

char的类型的大小要跟机器的最基础字符集相符合。

在一般的机器中，最小的是一个字节。

所以char一般是一个字节。

这里没问题吧。

C++ 11中新加入了一个long long。

当初设计这些类型时有一个原则：

一个int类型的尺寸大小至少和一个short一样大。

一个long类型的尺寸大小至少和一个int一样大。

一个long long类型的尺寸大小至少和一个long一样大。

记住了额。没关系，迅速过一遍。

下面有一个重点要讲一下。

就是从机器层面来看类型。

笔试中会经常涉及到。

我们都知道计算机内存只有0和1.

有句话，0和1改变了世界。

这个东西叫位。

一般来说一个字节是8位。

叫byte

然后是word,翻译成字

一般是2个字节。

16位

下面看内存的布局

 

小虾(578032311)14:30:14

汉字么。。word

gump(915537522)14:31:16

大部分机器上1word=2byte

右边的是内存的0，1链

左边是地址

注意下，这个地址其实是不在内存里的。

是人为编的。

好的。我们可以地址代表这个字节。

也可以用地址表示一个word。

下面继续。看看怎么抽象出类型这个概念的。

所谓的类型从底层来看，就是位的个数不同而已，以及解释它的方式不

一样而已。

我举个例子

在32位机器上看int。它是有32位的01组成。

内存里面有好多个0和1.解释的方式就是我每次只取4个字节作为整体。

而不是2个字节。

Typically, floats are represented in one
word (32 bits), doubles in two words (64 bits), and long doubles in either three 

or four words (96 or 128 bits). The float and double types typically yield about 7
and 16 significant digits, respectively. The type long double is often used as a

 wayto accommodate special-purpose floating-point hardware; its precision is

 more likely to vary from one implementation to another.

 

Signed and Unsigned Types

有符号数就是正负数加0

无符号数就是大于等于0的数。

默认的类型是signed

比如说，int ,short, long, and long long

在前面加个unsigned就成了无符号数

The type unsigned int may be abbreviated as unsigned.

但是基础的char类型有三种形式：char ,signed char,and unsigned char

这是特殊情况。

不过具体的表示还是只有signed and unsigned

那char到底是无符号的还是有符号的呢？

谁来回答一下。

 

深圳-工作-流岚<[e-mail]>14:52:10

这也有符号？？？？它的符号能干嘛用？？？

Scorpio<[e-mail]>14:52:41

跟编译器有关

gump(915537522)14:52:51

嗯，对的。@Scorpio 

深圳-工作-流岚<[e-mail]>14:52:58

语言关心编译器么？？？

Scorpio<[e-mail]>14:53:04

不是,本身是无关的，但是会出bug

所以一般如果你要用无符号的。就加上unsigned

gump(915537522)14:54:15

In an unsigned type , all the bits represent the value. For example, an 8-bit unsigned

 char can hold thee values from 0 through 255 inclusive.

就是说没有符号位。所有的位都表示值。

比如说，8位unsigned char的范围是0到255.

即，0000 0000 -  1111 1111

深圳-工作-流岚<[e-mail]>14:56:10

signed char就是ascii码了？

gump(915537522)14:56:49

都是啊

标准没有指定signed的具体表示，只给了一个范围。

具体的实现方式取决于编译器的设计者。

而大家一般都采用补码方式表示有符号数。

 

Advice: Deciding which Type to use

几点说一下：

1.Use an unsigned type when you know that the values cannot be negative.

知道数字不是负的，就用unsigned

2.使用int来表示整数。short通常比较小，而实际中一般long的大小和int一样大，

如果数字真的比较大，就直接用long long.

3. 在算术表达式中，不要使用plain char和bool。

因为刚才说了，char到底是signed还是unsigned都不知道。

只有在保存字符时用char.

保存truth值是用bool。

4.浮点数请直接用double，不要用float

大部分机器上，双精度比单精度运算快。精度高。

In fact, on some machines, double-precision operations are faster than single

 

类型转换

类型转换有强制的和自动的。

 

bool b=42;

int i=b;

i=3.14;

double pi=I;

unsigned char c=-1;

signed char c2=256

 

分别解释下。

第一个b=true，没问题。

第二个i=1

第3个i是3

这几个没问题吧。

第4个pi=3.0

Scorpio<[e-mail]>15:10:57

你要问c是多少

gump(915537522)15:11:20

嗯，重点是解释下面2个。

独有的回忆<[e-mail]>15:11:25

c应该是255

gump(915537522)15:11:40

对的。-1是最大的。在无符号里面。

Scorpio<[e-mail]>15:12:07

c2咧

gump(915537522)15:13:31

嗯。刚才涉及一个问题。当一个数超出无符号范围时，会从头开始算。

循环着来。

独有的回忆<[e-mail]>15:13:50

c2我不知道

Scorpio<[e-mail]>15:13:51

所以是-255

gump(915537522)15:14:02

错了。

独有的回忆<[e-mail]>15:14:11

signed啊

gump(915537522)15:14:33

但是有个原则，当把一个超过范围的数赋值给一个有符号数时，就是未定义的。

所以大家记住了。

 

If we assign an out-of range value to an object of signed type, the result is undefined.

 The program might appear to work, it might crash, or it might produce garbage values.

小虾(578032311)15:15:07

0么

gump(915537522)15:15:11

循环着来只适合无符号数。

独有的回忆<[e-mail]>15:15:53

阿甘，那这里的c2不确定？

gump(915537522)

15:16:00

对的。

未定义行为。

256超过了signed的范围了。

但如果是unsigned就从头开始算。

 

独有的回忆<[e-mail]>15:17:35

要是128呢

gump(915537522)15:18:33

也是未定义。

如果signed的范围是-128到127

most modern machines use representations that allow values from –128 through
127.

独有的回忆<[e-mail]>15:20:47

128可以表示为1000 0000啊

独有的回忆<[e-mail]>15:21:32

对的，是这样表示

这个有符号数好像是-128

gump(915537522)15:22:25

1000 0000变成有符号的数是128-256=-128

 

独有的回忆<[e-mail]>15:23:07

对呀，所以应该是-128吧

gump(915537522)15:23:33

对啊，那又怎么了。

它在范围中。

独有的回忆<[e-mail]>15:24:13

所以signed char c=128,c应该是-128吧

Scorpio<[e-mail]>15:25:11

是-128在范围内，不是128

独有的回忆<[e-mail]>15:25:55

@Scorpio 感觉我那个对不对啊

Scorpio<[e-mail]>15:26:21

不对啊。128超出了，所以是为定义

Scorpio<[e-mail]>15:26:28

这个我之前也不知道

Scorpio<[e-mail]>15:26:50

有符号不是-128到127嘛

独有的回忆<[e-mail]>

15:26:59

阿甘说的是无符号数啊

Scorpio<[e-mail]>15:27:36

到底是有符号还是无符号

gump(915537522)15:27:45

我说有符号啊

Scorpio<[e-mail]>15:28:18

无符号0到255有符号-127到128

不对,反了

独有的回忆<[e-mail]>15:28:31

-128~127

gump(915537522)15:28:47

超过有符号范围的数赋给有符号时是未定义的。

超过无符号数范围的数赋给无符号时是循环着来。

独有的回忆<[e-mail]>15:29:58

我测试的是-128

gump(915537522)15:30:24

说重点

独有的回忆<[e-mail]>15:30:57

signed char c=128;
c是-128

gump(915537522)15:31:26

我测的是没有值

就算是-128也不一定对。

因为是未定义的。你用的是什么编译器？

独有的回忆<[e-mail]>15:31:56

gcc version 4.8.1 (Ubuntu/Linaro 4.8.1-10ubuntu9)

gump(915537522)15:32:37

Scorpio<[e-mail]>15:32:52

刚才的英文 说了

gump(915537522)15:32:53

你程序贴出来。

Scorpio<[e-mail]>15:32:56

有很多种可能

独有的回忆<[e-mail]>15:33:09

我感觉应该都是训话着来的，我说下理由

Scorpio<[e-mail]>15:33:10

就gump截图那里

独有的回忆<[e-mail]>15:33:40

因为机器表示都是按一个字节表示

最高位的解释由我们自己来决定的

像128

Scorpio<[e-mail]>15:34:12

it may produce garbage value

独有的回忆<[e-mail]>15:34:21

机器表示为1000 0000

gump(915537522)15:35:06

你是不是写的C语言啊

独有的回忆<[e-mail]>15:35:25

#include <stdio.h>
int main(){
signed char c=128;
printf("%d\n",c);
return 0;
}

gump(915537522)15:35:49

我TM在讲C++

我g++测试的是未定义结果。

说下刚才的未定义行为具体是什么意思。

未定义就是编译器不需要检测的错误。

使编译通过，执行一个未定义表达式的程序也是错误的。

即

Unfortunately,programs that contain undefined behavior can appear to execute correctly

 in some circumstances and/or on some compilers. 

有时候也能执行正确！

所以我们要避免这种情况。

再举个例子来说明这个情况。

你不能假设int的尺寸是固定的，因为它是

implementation-defined

所以你要写出好的代码，就必须用sizeof(int)来代替int的尺寸。

为了体现出对技术的尊重，我们要这样做哈。

using a boolin an arithmetic expression
is almost surely incorrect.

不要乱用bool，上面已经说过了。

 

Expressions Involving Unsigned Types

gump(915537522)15:44:57

刚才是赋值时的类型转换。

现在是混合运算时的类型转换。

For example,if we use both unsigned and int values in an arithmetic expresssion,the int

 value ordinarily is converted to unsigned.

unsigned与int混合时，int会自动转成unsigned

下面看个例子：

第一个是-84

第二个算的结果就不是-32了.

先要把-42转换成无符号的数，再与int做计算

具体计算过程：-42+2^32+10=？

保证结果不能是负数。

道理和上面一样。

看个例子

会造成死循环吗？

肯定不会。

既然要保证i是正数，我们为什么不把i的类型改成unsigned的呢，正好符合上

面c++ primer的建议。

于是得到：

这个会造成死循环。

Scorpio<[e-mail]>15:55:50

你就是要死循环的效果是吧

囧，刚开始没看懂

gump(915537522)15:57:03

这个题面试的时候出现过。

道理一样，这里就不解释了。

我们可以把循环改成：

就会避免死循环。

Scorpio<[e-mail]>15:59:04

上面那个for去掉=也不会死循环

是吧

gump(915537522)15:59:41

是的。

但是我们希望打印出0

Scorpio<[e-mail]>16:00:55

上面那个也可以打印出0呀

gump(915537522)16:01:25

It is essential to remember that signed values are automatically converted to unsigned.

独有的回忆<[e-mail]>16:01:25

上面的不行

Scorpio<[e-mail]>16:01:37

--u为什么不行

独有的回忆<[e-mail]>16:01:55

for要先判断

Scorpio<[e-mail]>16:02:17

好像是的

忘了

gump(915537522)16:02:48

继续。signed和与unsigned混合，会转成unsigned运算。

举个例子

a*b,a=-1,b=1

如果a和b都是int，值就是-1

如果，a是int，b是unsigned的话，就不是-1了。

OK，关于singed和unsigned就这么多内容。

 

Literals

 

学渣<[e-mail]>16:08:35

看来for和while有时候还是有区别的

独有的回忆<[e-mail]>16:09:15

嗯，边界条件还是有点不一样的

学渣<[e-mail]>16:09:50

比如像上面的这个例子，如果非要用for实现呢？

独有的回忆<[e-mail]>16:10:24

和while一样

把--u放在循环体里面

gump(915537522)16:13:56

好，继续，下面讲字面量。

比如说42，就是一个字面量。

怎么理解字面量呢

”字面量“，从字面上就能看出来的。

A value, such as 42, is known as a literal because its value self-evident.

它有固定的类型。

 

Integer and Floating-Point Literals

没问题吧。迅速过一遍。

十进制，八进制以0开头，十六进制以0x开头

那么类型怎么判断呢？

举个例子，10 是什么类型？

 

独有的回忆<[e-mail]>16:18:19

int

gump(915537522)16:18:25

为什么？

为什么不是long

独有的回忆<[e-mail]>16:18:48

这个还真没想过

深圳-工作-流岚<[e-mail]>16:18:57

int省空间

独有的回忆<[e-mail]>16:19:05

好像是默认吧

gump(915537522)16:19:19

@深圳-工作-流岚 对的。

跟最近的类型来匹配。

一个10根本没必要搞个long来存储。

八进制和十六进制，道理一样。

Octal and hexadecimal
literals have the smallest type of int, unsigned int, long, unsigned long,
long long, or unsigned long longin which the literal’s value fits. 

It is an error to use a literal that is too large to fit in the largest related type.

类型short没有字面量。

看个表：

大家不要记住它们。只要知道有这个东西，用的时候再去查。

前缀和后缀可用来描述类型。

技术上说，十进制字面量是没有负数的。

举个例子：-42

负号不是字面量的一部分。

The minus sign is not a part of the literal.

The minus sign is an operator that negates the value of its (literal) operand.

下面讲浮点数

计算机内部是采用科学计数法来表示浮点数的。

include either a decimal point or an exponent specified using scientific notation

e或E表示指数。

默认的浮点字面量是double型。

We can override the default using
a suffix from Table 2.2(overleaf).

可以用后缀改写默认的。

关于浮点数在内存中的表示后面再讲。

 

Character and Character String Literals 

char是嵌在单引号中的

string字面量是嵌在双引号中的

A character enclosed within single quotes is a literal of type char. Zero or more

 characters enclosed in double quotation marks is a string literal/

它的类型是什么？

是常量字符的数组。

记住，类型不是string啊。

有时候后面的东西会混淆或者不理解就是因为基础概念掌握的不扎实。

它是一个数组。

末尾以\0结束。

The actual size of a string literal is one more than its apparent size

这个不用解释。

分隔字符串用spaces,tabs,or newlines

 

Escape Sequences

好像中文翻译叫转义序列

它们是不可打印的，或者是语言中本身有特殊含义的。

举2个例子：\n和\"

前者不可显示的，后者的"在语言中有特殊含义。

为了能使用它们，就用个\来使用。

\x后面跟一个或跟多的十六进制数字。\后面跟一到三个八进制数字。

它们的含义表示字符的数字值。

那请问\1234怎么解释？

\123  和4

\x不存在这个问题，后面随便跟几个数字。

 

Specifying the Type of a Literal

第一个类型是wchar_t，第二个是utf-8 字符串字面量。

utf-8 encodes a Unicode character in 8 bits

utf-8的含义。

第三个是unsigned long long

依次是float,long double

 

Boolean and Pointer Literals

nullptr是一个指针字面量。

 

独有的回忆<[e-mail]>16:43:56

utf-8就是char么

gump(915537522)16:44:36

嗯。八位的unicode character

也是字符。

char是小字符。

ascii码

wzq(793859693)16:45:31

小字符？七位的意思？

gump(915537522)16:45:39

对的。

事实上是8位，一位是校验码。

这些了解一下就可以了。继续吧。

2.2 Variables

gump(915537522)16:46:59

变量是什么？

我们都知道程序需要操纵内存，那么怎么操纵内存呢？

于是需要给内存起一个名字

而这个名字就对应在了程序语言里面的变量。

所以变量就是一块你起了名字的内存。

类型决定变量在内存中的尺寸大小和布局。

这在前面已经说过了。

值可以存放在内存里面。

C++ programmers tend to refer to
variables as “variables” or “objects” interchangeably

操作的集合能够应用到变量。

变量也叫对象。在C++中。

简单的变量定义：

前面是类型指定符

多个变量用逗号隔开，分号表示一个语句。

类类型对象，跟内部类型变量一个道理。

前面说到了常量字符数组，这里说下string类型

string表示可变长度的字符序列。

是C++标准库中的类型。

为了解决C语言中char*缺点。

从机器的角度来看。

对象就是一个有类型的内存区域。

后面讲STL时会详细介绍。

 

Initializers

下面说初始化。

就是，对象在创建的时候给它一个值。

Initializationin C++ is a surprisingly complicated topic and one we will return to
again and again.

初始化会在后面深入学习。

在C++中，初始化和赋值是不同的操作。

初始化就是在对象创建那一刻给它个值。

赋值是用一个新的值干掉对象当前的值。

 

List Initialization

C++ 11新的初始化的几种方式。