一、string key=str; sort(key.begin(), key.end());
二、emplace_back优于push_back,能就地通过参数构造对象，不需要拷贝和移动内存，提升容器插入性能；
三、swap(nums[i], nums[i-1]);
四、vec.at(rand()%(vec.size())),at比下标访问更安全，不会越界报错---------随机访问vec中的元素；
五、private:
vector<vector> rectangle;
public:
SubrectangleQueries(vector<vector>& rectangle) : rectangle(rectangle) {}
构造函数的成员函数列表初始化
六、return {array1[i],array1[i]+n};直接返回数组；
七、accumulate（arr.begin(), arr.end(), 0）,0规定了返回的和的类型；
八、set.contains(n),判断unordered集合中是否包含n;
九、set st(vec.begin(), vec.end());
十、arr2.find(avg-sum1+n)!=arr2.end() set的find返回迭代器；
十一、vector<vector> dp(n, vector(2));
dp[0][0]=0, dp[0][1]=-prices[0];
十二、字母和字符串的大小写转换strupr，strlwr，toupper，tolower
十三、1、sort(vec.begin(), vec.end(),
[](const pair<string, string> &p1, const pair<string, string> &p2){
return p1.second==p2.second ? p1.first<p2.first : p1.second>p2.second;
});对应升序，降序排列；

2、sort(envelopes.begin(),envelopes.end(),[](const vector<int> &a,const vector<int> &b){
        if(a[0]==b[0])
        return a[1]>b[1];
        else 
        return a[0]<b[0];
    });

3、sort(b.begin(),b.end(),[](const auto& L, const auto& R){return L[1] > R[1];});
十四、C++ stringstream 类是一种十分有用的类，特别是当我们需要在程序中使用字符串和数字数据互相转换的时候。
要想在程序中使用 stringstream 类，我们需要在源程序文件中包含头文件include。stringstream 对象的
使用方法与cout对象的使用方法基本相同。当我们需要按预定的格式将程序中的数据保存在一个string 中的时候，可以
先创建一个stringstream 对象，并通过运算符 ”<<“ 将数据传递给 stringstream 对象。
十四、str = to_string(sum % 10) + str;
十五、aNum = i > (aLen - 1) ? 0 : a[aLen - i - 1] - ‘0’;
十六、while(str.find(‘0’)==0){
str.erase(0,1);
}
十七、 size_t idx = r.find_first_not_of(‘0’);
cout << (idx == string::npos ? “0” : r.substr(idx)) << endl;
十八、#include ，使用typeid(变量名).name()来获取变量类型。
十九、// 去掉首尾位置中不需要的“0”
res = res.substr(res.find_first_not_of(“0”),
res.find_last_not_of(“0”) - res.find_first_not_of(“0”) + 1);
ans.push_back(res);
二十、// 将vector 转为 string
stringstream ss;
copy(vec.begin(), vec.begin() + res.size() + r.size(),
ostream_iterator(ss, “”));
res = ss.str();
vec.assign(vec.size(), 0);
二十一、r.erase(r.find(“.”), 1);
二十二、a-z:97-122,A-Z:65-90,0-9:48-57；
二十三、都是C++的字符处理函数，把数字字符串转换成int输出
②头文件都是#include
不同点：
①atoi()的参数是 const char* ,因此对于一个字符串str我们必须调用 c_str()的方法把这个string转换成 const char类型
的,而stoi()的参数是const string,不需要转化为 const char*；
二十四、pow((m1*2+1),2) #include
二十五、C++ 内置函数 判断字母、数字及大小写转换
c++的几个内置函数
islower(char c) ：是否为小写字母
isupper(char c)： 是否为大写字母
isdigit(char c) ：是否为数字
isalpha(char c) ：是否为字母
isalnum(char c)： 是否为字母或者数字
toupper(char c)： 字母小转大
tolower(char c) ：字母大转小
to_string(int i)：int转string
二十六、j=‘1’, int(j)=49
二十七、int gcd(int m, int n)
{
if (m%n == 0) return n;
else return gcd(n, m%n);
}求最大公约数算法
三十八、C++中min_element()与max_element（）（取容器中的最大最小值）
三十九、遍历有序map，按key递增输出；
四十、char a[3] = “He”;
四十一、vec.erase（）后返回指向下一个元素的迭代器。
四十二、int a = 2; 则！！a=1(取两次反)；
四十三、复合运算符优先级低于四则运算符t -= t + 2;(会先算加法)；
四十四、按位取反操作-1和0互为取反值；其他值+1再取符号；（~）
四十五、函数参数列表、Kent Beck简单设计四原则（通过所有测试用例、尽可能消除重复、更少代码元素、尽可能清晰表达）、
四十六、char和short在进行运算时，会自动先转换为int；
四十七、父类是抽象，子类实现的是细节。子类实现的细节比父类大，A *pa = new B()
相当于缩小子类的范围。这是设计模式的里氏替换原则；
四十八、C++语言规定，运算符“=”、“[]”、“()”、“->”以及所有的类型转换运算符只能作为成员函数重载。
四十九、将拷贝构造函数或者赋值操作符设置为private，并且不实现：
class Foo {
private:
Foo(const Foo&);
Foo& operator=(const Foo&);
};
// 同时出现
class Foo {
public:
…
Foo(const Foo&);
Foo& operator=(const Foo&);
…
};

// 同时default， C++11支持
class Foo {
public:
Foo(const Foo&) = default;
Foo& operator=(const Foo&) = default;
};

// 同时禁止, C++11可以使用delete
class Foo {
private:
Foo(const Foo&);
Foo& operator=(const Foo&);
};
五十、移动构造函数和移动赋值操作符都是具有移动语义的，应该同时出现或者禁止。

// 同时出现
class Foo {
public:
…
Foo(Foo&&);
Foo& operator=(Foo&&);
…
};

// 同时default， C++11支持
class Foo {
public:
Foo(Foo&&) = default;
Foo& operator=(Foo&&) = default;
};

// 同时禁止, 使用C++11的delete
class Foo {
public:
Foo(Foo&&) = delete;
Foo& operator=(Foo&&) = delete;
};

五十一、在构造函数和析构函数中调用当前对象的虚函数，会导致未实现多态的行为。
在C++中，一个基类一次只构造一个完整的对象。

示例：类Base是基类，Sub是派生类

class Base {
public:
Base();
virtual void Log() = 0; // 不同的派生类调用不同的日志文件
};

Base::Base() // 基类构造函数
{
Log(); // 调用虚函数Log
}

class Sub : public Base {
public:
virtual void Log();
};
当执行如下语句：
Sub sub;
会先执行Sub的构造函数，但首先调用Base的构造函数，由于Base的构造函数调用虚函数Log，此时Log还是基类的版本，只有基类构造完成后，才会完成派生类的构造，从而导致未实现多态的行为。
同样的道理也适用于析构函数。

五十二、只有基类析构函数是virtual，通过多态调用的时候才能保证派生类的析构函数被调用。

基类的析构函数没有声明为virtual会导致内存泄漏（由于基类Base的析构函数没有声明为virtual，当对象被销毁时，只会调用基类的析构函数，不会调用派生类Sub的析构函数，导致内存泄漏。）。
五十三、如果某个类需要实现多重接口，可以通过多重继承把多个分离的接口组合起来，类似 scala 语言的 traits 混入。（多重继承）这里不是单根继承。

class Role1 {};
class Role2 {};
class Role3 {};

class Object1 : public Role1, public Role2 {
// …
};

class Object2 : public Role2, public Role3 {
// …
};
五十四、内联函数具有一般函数的特性，它与一般函数不同之处只在于函数调用的处理。一般函数进行调用时，要将程序执行权转到被调用函数中，然后再返回到调用它的函数中；而内联函数在调用时，是将调用表达式用内联函数体来替换。
内联函数只适合于只有 1~10 行的小函数。对一个含有许多语句的大函数，函数调用和返回的开销相对来说微不足道，也没有必要用内联函数实现，一般的编译器会放弃内联方式，而采用普通的方式调用函数。
如果内联函数包含复杂的控制结构，如循环、分支(switch)、try-catch 等语句，一般编译器将该函数视同普通函数。
虚函数、递归函数不能被用来做内联函数。
五十五、单个对象删除使用delete， 数组对象删除使用delete []，原因：
调用new所包含的动作：从系统中申请一块内存，并调用此类型的构造函数。
调用new[n]所包含的动作：申请可容纳n个对象的内存，并且对每一个对象调用其构造函数。
调用delete所包含的动作：先调用相应的析构函数，再将内存归还系统。
调用delete[]所包含的动作：对每一个对象调用析构函数，再释放所有内存
如果new和delete的格式不匹配，结果是未知的。对于非class类型， new和delete不会调用构造与析构函数。
五十六、/ 保证初始化
int x; // 编译正确，没有初始化
auto x; // 编译失败，必须初始化

五十七、delete类的指针对象前会先运行析构函数？
五十八、%s格式化占位符可能导致内存任意写风险？
五十九、int 也可以通过编译？
六十、全局类对象的构造函数总是在main函数之前执行？
六十一、攻击者会破坏程序的运行环境，因此要对本地的操作系统环境变量、配置文件数据进行严格校验
六十二、inline函数，局部static对象在不同cpp文件访问时共享；
class、struct、union定义内定义的成员函数为隐式inline函数；
inline含义非强制
六十三、强类型枚举：同一作用域不会因为两个枚举类型有相同的元素值而冲突；
传统枚举类型：枚举元素类型可以自动转换为int类型；
六十四、使用原子操作通常比加锁性能高、使用原子操作需要选择合适的memory order、原子操作是实现无锁算法的基础；
六十五、为了保证分配合适的内存空间、必须对指定申请内存大小的整数值进行合法性校验
六十六、非const右值对象初始化对象时，优先移动构造函数；左值对象初始化对象，优先拷贝构造函数？
六十七、安全函数返回值处理方式：记录日志、返回错误、发生致命错误时，程序无法继续执行时，可以退出程序
六十八、int input[3] = {3, 3, 3}
vector numbers;
numbers.insert(numbers.begin(), input, input + 6);vector插入赋值操作；
六十九、调用含vector接口的方式interface（vector{7, 9}）;
七十、对于关联容器，查找时最好使用自己提供的成员函数；
七十一、const int类型指针可以指向非const int对象，int类型指针不可以指向const int对象。
七十二、对于内置函数必须默认初始化，string不用，它是是一个类，会默认初始化为空串；
七十三、printf(“value = 0x%.8x”, result);输出8位16进制；
七十四、int* p[10]; // an array with 10 int*
int (*p)[10]; // a pointer points to a 10-int array, i.e. a double pointer
int (p[10])(int)声明了p是一个元素为函数指针的数组
七十五、二维数组中第一维的长度没指定时，就会按最大的二维长度划分去初始化
int xs[][2]= {0, 1, 2}，则{0,1}和{2}
七十六、int x = 3, y;
int *px = &x;
y = px++;
会先运行px，然后赋值给y，然后再++，所以为3
七十七、 函数模板在编译期会根据调用类型实例化，对不同的参数类型会生成不同的实体函数。
七十八、 函数对象可以在几次调用之间保持状态。通过将operator()声明为inline，可建议编译器将函数对象的调用进行内联。函数调用操作符可以被重载。函数对象比函数指针性能高；
七十九、linux进程映射空间：动态加载的libc库映射到用户态空间内； 物理内存管理映射到内核态空间内；应用程序的data、text、bss段位于用户态空间内； 用户进程在用户态有栈空间，在内核态也有对应的栈空间
八十、coredump是操作系统在进程收到某些信号而终止运行时（程序崩溃），生成的一个磁盘文件，通常包含：寄存器状态；堆栈指针；内存管理信息；调用栈信息。
coredump数据对于定位程序异常崩溃非常有帮助，但有时候程序崩溃却未生成此文件，可能程序调用了seteuid()/setegid()改变了进程的有效用户或组；ulimit -c限制过小；coredump的目录不存在或进程对该目录没有写权限
八十一、异步线程安全函数：fork() . read() . socket() . strcpy()
八十二、运行中实际可能发生的错误，如文件打开失败，是不能用断言来检查的
八十三、断言必须使用宏来定义，在发布版本时，断言中的宏必须是关闭的
八十四、socket句柄成功关闭后，应立即对已关闭的socket句柄赋予一个无效值；
八十五、库函数 int atoi(const char *str) 把参数 str 所指向的字符串转换为一个整数（类型为 int 型）
atoi（“50Y”）==50
八十六、库函数 char *strcat(char *dest, const char *src) 把 src 所指向的字符串追加到 dest 所指向的字符串的结尾。
八十七、Result of comparison of constant 4 with expression of type ‘bool’ is always true：：死循环
八十八、虚函数是动态绑定的。内联是编译时刻就可决定的，而虚函数是运行时刻动态的决定执行哪段代码，所以虚函数不可能做为内联函数。虽然在虚函数前加上inline不会报错，但是会被忽略，不会被处理成内联。
八十九、虽然静态函数不存在this指针，但是还是不能声明同名同参的虚函数和静态函数。（static void fun();virtual void fun();）
九十、通过子类对象的指针删除子类对象时，无论父类的析构函数是不是虚的，都会调用父类的析构函数。但是通过父类对象的指针（指向子类对象）删除对象时，如果父类的析构函数不是虚的，那么就不会调用子类的析构函数。所以为了保证正确性，要将会被派生的类的析构函数声明为虚的。
九十一、以指针和引用的方式调用才会有多态

九十二、虚函数在父类中没有实现，父类先构造，调用会出错，在构造函数中调用（纯）虚函数，不会有虚函数的效应，只会调用父类本身的那个函数定义体，如果父类没有给出函数定义，就会链接出错，但也却实是因为对象的构造顺序决定了不能调用子类的函数体（父类在构造的时候，子类还没有构造呢，当然不会有虚函数效果
九十三、函数加上const修饰与不加const，实际上声明了两个不同的函数。所以在父类中加上const，但是子类同名同参的函数没有加const，他们是两个不同的接口。
九十四、子类可以访问父类的保护成员，子类的友元类也可以通过子类对象去访问父类的保护成员。
九十五、基类是虚函数，在派生类中即使定义时没有加virtual也是虚函数。
九十六、基类的构造函数=>派生类的构造函数=> … =>派生类的析构函数=>基类的析构函数。
九十七、class B、C都包含有class A，所以都有各自的 n，两个n的值不同
九十八、友元(friend)破坏了类的封装。友元有可以访问类个部分的能力，从而破坏了访问控制。
九十九、友元(friend）能直接访问类的private的成员变量和使用private的成员函数。（友元什么都能访问）类三种访问限定符和友元。
一百、class默认的访问控制是私有的，而struct则是公有的。
一百零一、对于内置数据类型的操作符，它预定义的意义不能被修改；也不能为内置数据类型定义其它操作符。例如不能定义int operator+(int,int)；也不能定义void operator+(int[],int[])。
一百零二、类的析构函数可以是虚函数，但构造函数不可以。
一百零三、一个类的构造函数可以有多个，但析构函数只能有一个。构造函数可以重载，析构函数只能有一个，且不带任何参数。
一百零四、对于引用和指针赋值，不产生新对象。（CSomething &ra = a;CSomething *pA = c;）
一百零五、类B是通过public继承方式从类A派生而来的，且类A和类B都有完整的实现代码， 一个类B的实例对象占用的内存空间一定不少于一个类A的实例对象占用的内存空间。
一百零六、虽然抽象类的析构函数可以是纯虚函数，但要实例化其派生类对象，仍必须提供抽象基类中析构函数的函数体。
一百零七、A从B中派生，B定义了一个纯虚函数Virtual void fun(void) = 0; A在声明该方法时可以不带Virtual限定符，如：void fun(void);
一百零八、（throw e是只抛出此类异常，而throw则是抛出所有异常）C++异常的基本知识。通过一段程序，使大家对异常有基本的了解并熟悉在使用异常时，可能会发生的问题。错误的描述，因为不带变量的throw语句标识重扔出异常，直接将已有的异常对象往上一级抛出，而带了变量的throw语句表示一般的异常抛出语句，会产生一个临时变量往上一级抛出。
一百零九、虽然可以在构造函数中抛出异常，但应禁止在析构函数中抛出异常。原因可参考《More Effective C++》的第11条。
110、在typedef语句中不能有异常规格声明。（typedef void (*gf)() throw(int);）
111、（地址引用比拷贝引用效率高）在catch字句的参数中，传引用比传值效率更高。
112、（不能直接使用A中的元素）名字空间成员访问的三种方法（There are three ways to access the elements of a namespace: by explicit access qualification, the using-declaration, or the using-directive.），只有当前作用域的名字空间中的成员元素才可以直接访问。（using namespace A; using A::i; A::i++;）
113、使用指示 冲突在存在冲突的成员元素使用前都不会发生冲突，在使用时发生；
114、用关键字namespace定义的名字空间 “不” 必有一个显示的名字且是独一无二的（可以不指定名字）。
115、静态函数是不在类的空间里面的。）静态成员函数类不属于某一个类对象，而是属于类的全体对象的。在使用一个类的静态成员函数前，不一定要先生成该类的一个对象。
116、静态成员函数只能直接该问类的静态成员，或通过类对象间接访问类对象的非静态成员。）静态成员函数只能访问类的静态成员和静态成员函数。
117、预处理#include时，如果#include使用””，就从当前项目目录开始搜索头文件；如果使用<>，就从系统include目录开始搜索头文件。这些目录的具体位置可以在环境变量中指定。
118、C++对头文件名没有后缀要求，标准C++头文件名不带后缀。对于C的标准头文件，C++提供文件名前面加‘c’，后面没有后缀的相应头文件。C++代码中可以以C++文件名格式包含原来C的标准头文件，也可以用C的文件名格式包含原来C的标准头文件，但不存在去掉后缀的标准C头文件名。
119、头文件中：函数声明；宏定义；inline函数定义；extern 关键字声明的全局变量（不能定义常规函数）；
120、.H文件中使用extern 关键字声明的全局变量应该只在一个.CPP文件中定义。
121、（const定义时没有初始化，以后就没有机会了），常量在定义时应赋初始值。
122、函数指针可以用0来初始化或赋值，以表示该指针不指向任何函数。
123、如果两个指针p和q，指向同一数组，则他们可以进行关系运算，例如p<q, p != q，指针可以做减法运算，指针可以同整数相加减。
124、size_t sz参数是C++标准中专门提到的一种operator delete唯一的一种大概可以叫做重载的方式。如果两个同时提供了就只有不带这个扩展参数的生效了；而如果只有这一种则在operator delete被调用时此参数传递的是被删除对象的大小。（重载的new必须有一个size_t参数）
1）类的内存管理的成员函数（new函数）隐含是静态的，是否写static都正确。
2）operator new可以有多种重载形式。
125、二进制运算bai符包括：！du(非)，&(按位与)，|zhi(按位或)，^(按位异或)
126、switch 语句中的 expression 必须是一个整型或枚举类型，或者是一个 class 类型，其中 class 有一个单一的转换函数将其转换为整型或枚举类型。（不能是double类型）
127、数组名当做参数传给函数时，就退化成指针了
反之，这里sizeof（destBuff）是数组的大小

128、内联是编译时刻就可决定的，而虚函数是运行时刻动态的决定执行哪段代码，所以虚函数不可能做为内联函数。虽然在虚函数前加上inline不会报错，但是会被忽略，不会被处理成内联。
129、虽然静态函数不存在this指针，但是还是不能声明同名同参的虚函数和静态函数。
130、通过子类对象的指针删除子类对象时，无论父类的析构函数是不是虚的，都会调用父类的析构函数。但是通过父类对象的指针（指向子类对象）删除对象时，如果父类的析构函数不是虚的，那么就不会调用子类的析构函数。所以为了保证正确性，要将会被派生的类的析构函数声明为虚的。
131、char dest[8] = {0xAB, 0xAB, 0xAB, 0xAB, 0xAB, 0xAB, 0xAB, 0xAB} int iRet = snprintf_s(dest, 5,
8, “1234”);
132、move(str)，原本的str将会置为空；
133、数字签名：完整性、身份认证、防止交易中的抵赖发生
134、常用需求分析方法：客户场景分析、基于Use Case分析、DFX分析；
135、快排的步骤
136、
137、基本上下面的函数是不可重入的
（1）函数体内使用了静态的数据结构；
（2）函数体内调用了malloc()或者free()函数；
（3）函数体内调用了标准I/O函数。
138、strcat拼接在第一个/0后面；
139、保存在linux内核态空间中：与进程相关的数据结构，如页表、task和mm结构；内核代码段和数据段；内核物理地址信息
140、findbugs是检测java语言的静态工具，codemars和pc-lint是C语言的，coverity是C++的；
141、typedef struct Node2 {
int x;
char s[];
int y;
} Node2;
sizeof(Node2)
答案：编译错误
char s[];需要放到最后 或者给定具体数值 char s[2];
142、strncmp把 str1 和 str2 进行比较，最多比较前 n 个字节，若str1与str2的前n个字符相同，则返回0；若s1大于s2，则返回大于0的值；若s1 小于s2，则返回小于0的值。
143、

144、unsigned int a=20;
int b=13;
int k = b-a;
k<(unsigned int)b+a(unsigned int)b+a的值为33，为无符号数，因此在比较的时候k首先转换为无符号数(-7转换为无符号数为一个超大值)，所以k应该比33更大
145、struct tagSmart
{
char flag1;
int (*left_tree)[3];
struct tagSmart *right_tree[2];
char flag3;
char flag4;
}SmartFlag[4];
sizeof（SmartFlag）=？

struct tagSmart
{
char flag1;起始地址为0，有效对齐为1字节
int (*left_tree)[3];指向一个有3列的数组的指针，有效对齐为4字节，起始地址为4，结束地址为7
struct tagSmart *right_tree[2];指向struct tagSmart 的指针数组，有效对齐为4，长度为sizeof(指针)2 = 8,起始地址为8,，结束地址为15
char flag3;有效对齐为1字节，起始地址为16，结束地址为16
char flag4; 有效对齐为1字节，起始地址为17，结束地址为17
}整个结构体需要按照最大的有效字节进行对齐，结构体的最大有效字节对齐为4，因此结构体的大小为20，而SmartFlag为数组，总大小为204= 80
146、逗号运算符

147、栈是线程或者函数独占的，自动分配内存自动释放内存，A线程不能访问B的栈空间。函数也一样。而堆是公用的，如果程序员用完没有把内存置0的话，其他线程或者函数就有可能读取到敏感数据
148、
如果N<M 以M为准
如果N>M 就以N进行对齐
149、string(i, ‘0’);输出i个重复的字符串’0’;
150、sscanf(date.c_str(), “%d-%d-%d”, &year, &month, &day);把输入的字符串格式化到三个变量里；
151、二进制转字符串bitset<10> bit(“010101”);string str = bit.to_string();
字符串转二进制string str = “010101”;bitset<10> bit(str);
152、当new和delete操作符重载，new：先new函数，再构造函数；delete：先析构函数，再delete函数
153、

154、new和malloc都是不可重入
155、虽然抽象类的析构函数可以是纯虚函数，但要实例化其派生类对象，仍必须提供抽象基类中析构函数的函数体。
156、 A从B中派生，B定义了一个纯虚函数Virtual void fun(void) = 0; A在声明该方法时可以不带Virtual限定符，如：void fun(void);
157、函数模板缺省情况下不是内联的。
158、析构函数不允许抛出异常
159、C++的异常规格声明，在typedef语句中不能有异常规格声明。typedef void (gf)() throw(int);就不行
160、不能使用指示(the using-directive)可用于类的声明中。
161、类名::变量名、类指针->变量名、类对象.变量名
162、（由于静态成员函数没有当前对象this指针的信息，因此不能访问一般的数据成员，也只能调用其他的静态成员函数。朱老师的讲解：静态成员函数只能直接该问类的静态成员，或通过类对象间接访问类对象的非静态成员。）静态成员函数只能访问类的静态成员和静态成员函数。
163、#include机制用于将源程序片段收集在一起，形成一个完整的编译单元作为编译器的输入。
164、extern 关键字主要用于声明全局变量，如果同时给变量赋值则不是声明而是定义了。
165、.H文件中使用extern 关键字声明的全局变量应该只在一个.CPP文件中定义。
166、（const定义时没有初始化，以后就没有机会了）常量在定义时应赋初始值。
167、函数指针可以用0来初始化或赋值，以表示该指针不指向任何函数。
168、(p)++和(p++)都是先取值再++；
169、如果两个指针p和q，指向同一数组，则他们可以进行关系运算，例如p<q, p != q，指针可以做减法运算，指针可以同整数相加减。
170、字符串在c++里其实就是一个char型的指针，指向首地址, 常量字符串就是const char
171、重载成员 new 和delete 不管加没加static 都一定是静态的，申请内存的时候需要知道大小（size） 释放内存的时候需要知道内存首地址 （void p）具体大小在申请的时候会有一个cookie位记录
172、switch不能匹配字符串和浮点数（不精确）
173、由于存在对齐，机器的位长，因此结构中元素的排列会影响占用的空间大小，会有差异
174、C++ s.erase(0,s.find_first_not_of(" “));去掉首部的空格find first not of
s.erase(s.find_last_not_of(” ") + 1);去掉尾部的空格find last not of
175、利用includes(favoriteCompanies[j].begin(), favoriteCompanies[j].end(), favoriteCompanies[i].begin(), favoriteCompanies[i].end()) == true判断两个vector数组之间有没有从子集的关系；
176、s1.size()>s2.size()?s2+=string(s1.size()-s2.size(), ‘0’):s1+=string(s2.size()-s1.size(), ‘0’);三元作用符可以这样用
177、
178、llround

179、vector::iterator ite1 = find(vec_dis.begin(), vec_dis.end(), vec_dis1[0]);
auto index1 = std::distance(std::begin(vec_dis), ite1);获得vector里指定元素的索引
180、C++里的lower_bound(返回第一个大于等于x的数的地址)和upper_bound(返回第一个大于x的数的地址)
181、lower_bound() 函数用于在指定区域内查找不小于目标值的第一个元素
upper_bound() 函数用于在指定范围内查找大于目标值的第一个元素