1
2

string s;
cout << s[0] << endl;

1
2

const string s = "Keep out!";
for(auto &c : s){ /* ... */ }

1
2
3
4
5
6
7

vector<int> v1;         // size:0,  no values.
vector<int> v2(10);     // size:10, value:0
vector<int> v3(10, 42); // size:10, value:42
vector<int> v4{ 10 };     // size:1,  value:10
vector<int> v5{ 10, 42 }; // size:2,  value:10, 42
vector<string> v6{ 10 };  // size:10, value:""
vector<string> v7{ 10, "hi" };  // size:10, value:"hi"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

假设`txt_size`是一个无参函数，它的返回值是`int`。请回答下列哪个定义是非法的，为什么？


unsigned buf_size = 1024;
(a) int ia[buf_size];
(b) int ia[4 * 7 - 14];
(c) int ia[txt_size()];
(d) char st[11] = "fundamental";


解：

-   (a) 非法。维度必须是一个常量表达式。
-   (b) 合法。
-   (c) 非法。txt\_size() 的值必须要到运行时才能得到。
-   (d) 非法。数组的大小应该是12。

1

p1 += p2 - p1;

1
2
3

for： for语句可以省略掉 init-statement， condition和 expression的任何一个；甚至全部。

什么是“悬垂else”？C++语言是如何处理else子句的？ 解： 用来描述在嵌套的if else语句中，如果if比else多时如何处理的问题。C++使用的方法是else匹配最近没有配对的if 

1
2
3
4
5
6

12 / 3 * 4 + 5 * 15 + 24 % 4 / 2
解：
((12 / 3) * 4) + (5 * 15) + ((24 % 4) / 2) = 16 + 75 + 0 = 91

逻辑与运算符和逻辑或运算符都是先求左侧运算对象的值再求右侧运算对象的值，当且仅当左侧运算对象无法确定表达式的结果时才会计算右侧运算对象的值。这种策略称为 短路求值。
相等性运算符未定义求值顺序。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

解释在下面的if语句中条件部分的判断过程。

const char *cp = "Hello World";
if (cp && *cp)
解：

首先判断cp，cp 不是一个空指针，因此cp为真。然后判断*cp，*cp 的值是字符'H'，非0。因此最后的结果为真。

执行下述 if 语句后将发生什么情况？

if (42 = i)   // 编译错误。赋值运算符左侧必须是一个可修改的左值。而字面值是右值。
if (i = 42)   // true.

尽管下面的语句合法，但它们实际执行的行为可能和预期并不一样，为什么？应该如何修改？

if (p = getPtr() != 0)
if (i = 1024)
解：

if ((p=getPtr()) != 0)
if (i == 1024)

1
2
3
4
5
6
7
8

说明前置递增运算符和后置递增运算符的区别。

解：

前置递增运算符将对象本身作为左值返回，而后置递增运算符将对象原始值的副本作为右值返回。


(c) vec[ival++] <= vec[ival]  (c) 表达式有误。C++并没有规定`<=`运算符两边的求值顺序，应该改为`vec[ival] <= vec[ival+1]`

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

因为运算符的优先级问题，下面这条表达式无法通过编译。根据4.12节中的表指出它的问题在哪里？应该如何修改？


string s = "word";
string pl = s + s[s.size() - 1] == 's' ? "" : "s" ;


解：

加法运算符的优先级高于条件运算符。因此要改为：


string pl = s + (s[s.size() - 1] == 's' ? "" : "s") ;

1
2
3
4
5
6
7
8

推断下面代码的输出结果并说明理由。实际运行这段程序，结果和你想象的一样吗？如不一样，为什么？

int x[10];   int *p = x;
cout << sizeof(x)/sizeof(*x) << endl;
cout << sizeof(p)/sizeof(*p) << endl;
解：

第一个输出结果是 10。 第二个结果取决于机器。sizeof(p)即int*的内存空间大小, 32位机4B, 64位机8B; sizeof(*p)即sizeof(int), 通常为4B, C++标准规定其不得小于2B。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

说明形参、局部变量以及局部静态变量的区别。编写一个函数，同时达到这三种形式。

解：

形参定义在函数形参列表里面；局部变量定义在代码块里面； 局部静态变量在程序的执行路径第一次经过对象定义语句时初始化，并且直到程序终止时才被销毁。

// 例子
int count_add(int n)       // n是形参
{
    static int ctr = 0;    // ctr 是局部静态变量
    ctr += n;
    return ctr;
}

int main()
{
    for (int i = 0; i != 10; ++i)  // i 是局部变量
      cout << count_add(i) << endl;

    return 0;
}

1
2
3
4
5

使用class和struct时有区别吗？如果有，是什么？

解：

class和struct的唯一区别是默认的访问级别不同。'

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

封装是何含义？它有什么用处？

解：

将类内部分成员设置为外部不可见，而提供部分接口给外面，这样的行为叫做封装。

用处：

1.确保用户的代码不会无意间破坏封装对象的状态。
2.被封装的类的具体实现细节可以随时改变，而无需调整用户级别的代码。

1
2
3
4

s.eof()	若流s的eofbit置位，则返回true
s.fail()	若流s的failbit置位，则返回true
s.bad()	若流s的badbit置位，则返回true
s.good()	若流s处于有效状态，则返回true

1
2
3

什么情况下，下面的while循环会终止？
while (cin >> i) /*  ...    */
解：如badbit、failbit、eofbit 的任一个被置位，那么检测流状态的条件会失败。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

istream& func(istream &is)
{
    std::string buf;
    while (is >> buf)
        std::cout << buf << std::endl;
    is.clear();
    return is;
}

有些情况下我们希望提供cin作为接受istream&参数的构造函数的默认实参，请声明这样的构造函数。

解：

Sales_data(std::istream &is = std::cin) { read(is, *this); }

1
2
3
4
5

如果接受string的构造函数和接受istream&的构造函数都使用默认实参，这种行为合法吗？如果不，为什么？

解：

不合法。当你调用Sales_data()构造函数时，无法区分是哪个重载。    

1
2
3
4
5
6

下面这条声明合法吗？如果不，为什么？

vector<NoDefault> vec(10);//vec初始化有10个元素
解：

不合法。因为NoDefault没有默认构造函数。