C++ primer知识点整理

unsigned int可以简写为unsigned

When executed this statement would print:

执行这条语句将会输出：

     a multi-line string literal using concatenation

处理长字符串有一个更基本的（但不常使用）方法，这个方法依赖于很少使用的程序格式化特性：在一行的末尾加一反斜线符号可将此行和下一行当作同一行处理。

 // multiline string literal
           std::cout << "a multi-line \
      string literal \
      using a backslash"
                    << std::endl;
          return 0;
      }

1024f 非法，整数不能带f

3.14UL非法，浮点没有符号

直接初始化和复制初始化

int ival(1024);

int ival = 1024;

通过一个计数器和一个字符初始化string对象

string all_nines(10, '9');

判断题

int ival = ival; 正确

double salary = wage = 9999.99; 非法：同一定义语句中不同变量的初始化应分别进行

正确写法：

double salary, wage;

salary = wage = 9999.99;

extern string name("exercise 3.5a"); 这条语句是一个定义，但这个语句只能出现在函数外部，name是一个全局变量

const变量必须初始化：

      const int i, j = 0;  // error: i is uninitialized const

const 对象局部于文件创建

要使 const 变量能够在其他的文件中访问，必须地指定它为 extern

// file_1.cc
      // defines and initializes a const that is accessible to other files
      extern const int bufSize = fcn();
      // file_2.cc
      extern const int bufSize; // uses bufSize from file_1
      // uses bufSize defined in file_1
      for (int index = 0; index != bufSize; ++index)
            // ...

非const引用只能绑定到与该引用同类型的对象

const引用则可以绑定到不同但相关的类型的对象或绑定到右值

int i = 42;
      //  legal for const references only
      const int &r = 42;
      const int &r2 = r + i;


      double dval = 3.14;
      const int &ri = dval;

如果使用 class 关键字来定义类，那么定义在第一个访问标号前的任何成员都隐式指定为 private；如果使用struct 关键字，那么这些成员都是public。使用class 还是struct 关键字来定义类，仅仅影响默认的初始访问级别。

  struct Sales_item {
         // no need for public label, members are public by default
         // operations on Sales_item objects
     private:
         std::string isbn;
         unsigned units_sold;
         double revenue;
     };

#ifndef #endif的用法：

     #ifndef SALESITEM_H
     #define SALESITEM_H
     // Definition of Sales_itemclass and related functions goes here
     #endif

getline的使用：

     int main()
     {
         string line;
         // read line at time until end-of-file
         while (getline(cin, line))
             cout << line << endl;
         return 0;
     }

当进行 string 对象和字符串字面值混合连接操作时，+ 操作符的左右操作数必须至少有一个是 string 类型的：

     string s1 = "hello";   // no punctuation
     string s2 = "world";
     string s3 = s1 + ", ";           // ok: adding a string and a literal
     string s4 = "hello" + ", ";      // error: no string operand
     string s5 = s1 + ", " + "world"; // ok: each + has string operand
     string s6 = "hello" + ", " + s2; // error: can't add string literals

string可以直接和字符连接

#include <iostream>
#include <string>
using namespace std;
int main()
{
    string line("Hello world");
    char c = '!';
    line += c;
    cout << line << endl;
    return 0;
}

string::size_type;

vector<int>::size_type;

iterator:

     vector<int>::iterator iter = ivec.begin();

end操作返回的迭代器指向vector的“末端元素的下一个”，起到哨兵（sentinel）的作用，表示已经处理完vector中的所有元素

迭代器的自增和解引用运算：

    // reset all the elements in ivec to 0
     for (vector<int>::size_type ix = 0; ix != ivec.size(); ++ix)
             ivec[ix] = 0;

数组的维数，错误实例：

int staff_size = 27;            // nonconst
double salaries[staff_size];     // error: non const variable

vector不能这样赋值：

   vector<int> ivec = { 0, 1, 1, 2, 3, 5, 8 };

vector的复制：

#include <vector>
using namespace std;
int main()
{
    vector<int> ivec1(10, 20);
    vector<int> ivec2;
    for(vector<int>::iterator iter = ivec1.begin(); iter != ivec1.end(); ++iter)
        ivec2.push_back(*iter);
    return 0;
}

如果两个操作数为正，除法（/）和求模（%）操作的结果也是正数（或零）；如果两个操作数都是负数，除法操作的结果为正数（或零），而求模操作的结果则为负数（或零）；如果只有一个操作数为负数，这两种操作的结果取决于机器；求模结果的符号也取决于机器，而除法操作的值则是负数（或零）：

当只有一个操作数为负数时，求模操作结果值的符号可依据分子（被除数）或分母（除数）的符号而定。如果求模的结果随分子的符号，则除出来的值向零一侧取整；如果求模与分母的符号匹配，则除出来的值向负无穷一侧取整。

     21 % 6;   //  ok: result is 3
     21 % 7;   //  ok: result is 0
     -21 % -8; //  ok: result is -5
     21 % -5;  //  machine-dependent: result is 1 or -4
     21 / 6;   //  ok: result is 3
     21 / 7;   //  ok: result is 3
     -21 / -8; //  ok: result is 2
     21 / -5;  //  machine-dependent: result -4 or -5

将一个句子的第一个单词的各字符全部改成大写：

     string s("Expressions in C++ are composed...");
     string::iterator it = s.begin();
     // convert first word in s to uppercase
     while (it != s.end() && !isspace(*it)) {
         *it = toupper(*it); // toupper covered in section 3.2.4 (p. 88)
         ++it;
     }

cin.get()的使用：

char ch;
while(cin.get(ch))
{
    case ' ':
       ++spaceCnt;
       break;
}

对于实际的程序来说，float 类型精度通常是不够的——float 型只能保证 6 位有效数字，而double 型至少可以保证 10 位有效数字，能满足大多数计算的需要。

putchar() getchar() puts()的使用

指针和数组：

int ia[] = {0, 2, 4, 6, 8};
int *p = &ia[2];	//ok: p points to the element indexed by 2
int j = p[1];	//ok: p[1] equivalent to *(p + 1), 
				// p[1] is the same element as ia[3]
int k = p[-2];	//ok: p[-2] is the same element as ia[0]

typedef string *pstring;
const pstring cstr;
//等价于 string *cosnt cstr;