C/C++ 知识小结

xiaoma_bk

已于 2022-09-28 21:15:59 修改

阅读量2.2k

点赞数

分类专栏： # C\C++ 文章标签： c++

于 2019-04-23 14:28:29 首次发布

本文链接：https://blog.csdn.net/xiaoma_bk/article/details/89471837

版权

C\C++ 专栏收录该内容

22 篇文章 0 订阅

订阅专栏

C/C++ 小结

1.多重定义问题
- 1.多重问题
- 2.解决方法:
2.内存分配 malloc与calloc,以及relloc
- 1.简介：
- 2.说明
- 3. 案例
3.C++中map、hash_map、unordered_map、unordered_set的区别
- 3.1 hash_map、unordered_map
- 3.2 unordered_map与map
- 3.3 unordered_map与unordered_set
- 3.4 简易使用
- map 遍历
4.boost::filesystem 功能
- 1.boost库文档
- 2.boost::filesystem
- 3.基本功能
- 4.基本案例
- - 案例1
  - - 案例2
5. c++ 读写txt
- 1.小结
- 2.正常的读写
6.set list map
- 1.介绍
- 2.什么场景下使用list，set，map呢？
7.std :: tie、std :: make_tuple
- 1.两者比较
- 2.另一方面，tie
8.c++ yaml
- 1.CMakeList.txt中添加：
- 2.文件中：
- 3.具体使用：
- - 读
  - 写
9.unordered_set 模型
- 1.模板原型:
- 2.容器属性
- 3.扩容与缩容
10.指针学习总结
11.四舍五入
12 std::unique_ptr、shared_ptr
- 简易使用
13. 【C++ 异常】jump to case label [-fpermissive]
- 13.1 问题代码
- 13. 2 说明
- 13.3修改方法
- 13.4 深入了解
13 undef
14.c++14 std::make_unique
15 泛型模板函数 undefined reference to
- 15.1 问题
- 15.2 解决
- 15.3 案例
16. vector
- 16.1 vector 简介
- 16.2问题
- 释放vector的内存
17 STL set,,deque,queue,map
- 17.1 std::set
- 17.2 deque函数：
- 17.3. map、unordered_map
17 fill ,fill_n
- 17.1 fill
- 17.2. fill_n
18 queue vs deque
19 遍历

https://en.cppreference.com/w/cpp/algorithm

1.多重定义问题

1.多重问题

例如一个头文件headfile.h这样写

#pragma once
void Func (){}

在这个头文件被多个地方包含的时候就会出问题，链接时报错: (FuncB报重定义)
原因是，在headfile.h中定义了函数及其实现，如果被包含时，则会把函数实现放入包含的位置，被包含多次时，则会被放入多次，从而导致Func重定义。
那怕是在头文件中使用了 #pragma once或是#ifdef __xxx /#define __xxx/#endif也不能解决这种问题。原因是每个.cpp的编译都是多独立的，对于每个cpp来说，都是包含了Func的声明和实现，所以在链接时就不清楚到底是链接哪一个同名函数了。

2.解决方法:

2.1.添加inline标识，

添加完inline标识后，函数的内容代码被直接解释到调用处了，链接时相当于不存在这个函数，也就不存函数重定义的情况。

inline void Func (){}

2.2.添加static标识

static void Func (){}

2.3.放入到类中

class ClassA{
public: 
void Func () {}
}

对于静态函数和类，无论有多少文件包含它，也只会维护一份，链接时也就只能找到这一份，所以也是没有问题。

2.内存分配 malloc与calloc,以及relloc

1.简介：

malloc()与calloc() 功能都是用于动态内存的分配，两者略有差别。

malloc()用于一个大小的内存分配，void *malloc( size_t size );
calloc()用于多个对象的内存分配，void *calloc( size_t numElements, size_t sizeOfElement );

2.说明

1.分配内存空间函数malloc

调用形式： (类型说明符*) malloc (size)
功能： 在内存的动态存储区中分配一块长度为"size"，字节的连续区域。函数的返回值为该区域的首地址。
“类型说明符”表示把该区域用于何种数据类型。(类型说明符*)表示把返回值强制转换为该类型指针。 “size”是一个无符号数。
例如： pc=(char *) malloc (100);表示分配100个字节的内存空间，并强制转换为字符数组类型，函数的返回值为指向该字符数组的指针，把该指针赋予指针变量pc。

2.分配内存空间函数 calloc

调用形式： (类型说明符*)calloc(n,size)
功能： 在内存动态存储区中分配n块长度为“size”字节的连续区域。函数的返回值为该区域的首地址。
(类型说明符*)用于强制类型转换。calloc函数与malloc 函数的区别仅在于一次可以分配n块区域。
例如： ps=(struet stu*) calloc(2,sizeof (struct stu)); 其中的sizeof(struct stu)是求stu的结构长度。因此该语句的意思是：按stu的长度分配2块连续区域，强制转换为stu类型，并把其首地址赋予指针变量ps。

3.区别

malloc申请后空间的值是随机的，并没有进行初始化，而calloc却在申请后，对空间逐一进行初始化，并设置值为0;
calloc函数由于给每一个空间都要初始化值，那必然效率较malloc要低，并且现实世界，很多情况的空间申请是不需要初始值的，这也就是为什么许多初学者更多的接触malloc函数的原因。

3.relloc

realloc函数和上面两个有本质的区别，其原型void realloc(void *ptr, size_t new_Size)

**用于对动态内存进行扩容(**及已申请的动态空间不够使用，需要进行空间扩容操作)，ptr为指向原来空间基址的指针， new_size为接下来需要扩充容量的大小。
如果size较小，原来申请的动态内存后面还有空余内存，系统将直接在原内存空间后面扩容，并返回原动态空间基地址；如果size较大，原来申请的空间后面没有足够大的空间扩容，系统将重新申请一块(20+size)*sizeof(int)的内存，并把原来空间的内容拷贝过去，原来空间free;如果size非常大，系统内存申请失败，返回NULL,原来的内存不会释放。
注意：如果扩容后的内存空间较原空间小，将会出现数据丢失，如果直接realloc(p, 0);相当于free( p).

3. 案例

1.malloc 与 calloc 对比

int *p = (int *)malloc(20*sizeof(int));
    int *pp = (int *)calloc(20, sizeof(int));
    int i;
    printf("malloc申请的空间值:\n\n");
    for ( i=0 ; i < 20; i++)
        printf("%d ", *p++);
    printf("\n\n");
    printf("calloc申请的空间的值:\n\n");
    for ( i=0 ; i < 20; i++)
        printf("%d ", *pp++);
    printf("\n");

上面值随意输出，下面值 0

2.calloc 使用

  pf_kdtree_node_t **queue, *node;      //queue每个元素都是一个node
  queue = calloc(self->node_count, sizeof(queue[0]));

3.C++中map、hash_map、unordered_map、unordered_set的区别

3.1 hash_map、unordered_map

这两个的内部结构都是采用哈希表来实现，区别在哪里？

unordered_map在C++11的时候被引入标准库了，而hash_map没有，所以建议还是使用unordered_map比较好。
哈希表的好处是什么？- 查询平均时间是O(1)。

顾名思义，unordered，就是无序了，数据是按散列函数插入到槽里面去的，数据之间无顺序可言，但是有些时候我只要访问而不需要顺序，因此可以选择哈希表。

3.2 unordered_map与map

虽然都是map，但是内部结构大大的不同

map的内部结构是R-B-tree来实现的，所以保证了一个稳定的动态操作时间，查询、插入、删除都是O（logN），最坏和平均都是。
unordered_map如前所述，是哈希表。顺便提一下，哈希表的查询时间虽然是O（1），但是并不是unordered_map查询时间一定比map短，因为实际情况中还要考虑到数据量，而且unordered_map的hash函数的构造速度也没那么快，所以不能一概而论，应该具体情况具体分析。

3.3 unordered_map与unordered_set

unordered_set就是在哈希表插入value，而这个value就是它自己的key，而不是像之前的unordered_map那样有键-值对，这里单纯就是为了方便查询这些值。
举个大家好懂的例子，给你A,B两组数，由整数组成，然后把B中在A中出现的数字取出来，要求用线性时间完成。很明显，这道题应该将A的数放到一个表格，然后线性扫描B，发现存在的就取出。可是A的范围太大，你不可能做一个包含所有整数的表，因为这个域太大了，所以我们就用unordered_set来存放A的数，具体实现库函数已经帮你搞定了。

3.4 简易使用

  template <typename DataType>
  bool AddSensorData(const DataType& sensor_data){
    const std::string & frame_id = sensor_data.header.frame_id;
    if(map_sub_topics_check_.count(frame_id) == 0){
      map_sub_topics_check_.emplace(frame_id,SensorCheck());
      map_sub_topics_check_.at(frame_id).SaveReportPath(true,save_check_result_path_);
    }
    CHECK_NE(map_sub_topics_check_.count(frame_id),0);
    return map_sub_topics_check_.at(frame_id).AddSensorData(sensor_data);
  }

map 遍历

反向遍历

可以使用反向迭代器reverse_iterator反向遍历map映照容器中的数据，它需要rbegin()和rend()方法指出反向遍历的起始位置和终止位置。
```
 for(map<int,char>::reverse_iterator rit=m.rbegin();rit!=m.rend();rit++) 
 	cout<<(*rit).first<<","<<(*rit).second<<endl;    
```

查找

元素搜索：使用find()方法搜索某个键值，如果搜索到了，则返回该键值所在的迭代起位置否则，返回end()迭代器位置，由于map采用黑白树搜索，所以搜索速度极快。当然也可以用count()方法，但是需要如果想直接使用的话再使用键值搜索，需要两次查找，这时候就不如find功能好。

4.boost::filesystem 功能

1.boost库文档

boost库文档

2.boost::filesystem

boost::filesystem库提供了两个头文件，一个是<boost/filesystem.hpp>，这个头文件包括基本的库内容。它提供了对文件系统的重要操作。同一时候它定义了一个类path。正如大家所想的。这个是一个可移植的路径表示方法，它是filesystem库的基础。
一个是<boost/filesystem/fstream.hpp>。是对std::fstream的一个补充，使用能够使用类boost::path作为參数。从而使得filesystem库与标准库的关系更亲热。
由于文件系统对于大多数系统来说都是共享的，所以不同的进程能够同一时候操作同一个对象，因此filesysetm不提供这方面的特性保证。当然这样的保证也是不可能的。或者至少昂贵的。
filesystem在不论什么时候，仅仅要不能完毕对应的任务。它都可能抛出 basic_filesystem_error异常。当然并不是总会抛出异常。由于在库编译的时候能够关闭这个功能。同一时候有两个函数提供了无异常版本号。这是由于在任务不能完毕时并不是是异常。
filesystem库的全部内容定义在boost名字空间的一个下级名字空间里，它叫boost::filesytem。在使用boost.filesytem之后，链接时须要加“-lboost_filesystem-mt”选项，由于这个须要额外的链接，并不是一个纯头文件的库。

3.基本功能

boost::filesystem::+下面命令

路径是否存在和是否为路径 在路径后面加’/'没有区别。

system_complete(path); 返回完整路径(相对路径 + 当前路径)
exists(path); 目录是否存在文件、文件夹都可以
is_directory(path);
is_directory(file_status); 是否是路径检测路径
is_empty(path); 文件夹是否为空，必须保证路径存在，否则抛异常
is_regular_file(path);
is_regular_file(file_status); 是否是普通文件普通文件，非文件夹
is_symlink(path);
is_symlink(file_status); 是否是一个链接文件
file_status status(path); 返回路径名对应的状态
initial_path(); 得到程序运行时的系统当前路径
current_path(); 得到系统当前路径
current_path(const Path& p); 改变当前路径
space_info space(const Path& p); 得到指定路径下的空间信息，
space_info 有capacity, free 和 available三个成员变量，分别表示容量，剩余空间和可用空间。
last_write_time(const Path& p); 最后修改时间
last_write_time(const Path& p, const std::time_t new_time); 修改最后修改时间
bool create_directory(const Path& dp); 建立路径建立文件夹
create_hard_link(const Path1& to_p, const Path2& from_p);
error_code create_hard_link(const Path1& to_p, const Path2& from_p, error_code& ec); 建立硬链接
create_symlink(const Path1& to_p, const Path2& from_p);
create_symlink(const Path1& to_p, const Path2& from_p, error_code& ec); 建立软链接
remove(const Path& p, system::error_code & ec = singular); 删除空文件
remove_all(const Path& p); 删除文件以及以下的所有内容
rename(const Path1& from_p, const Path2& to_p); 重命名
copy_file(const Path1& from_fp, const Path2& to_fp); 拷贝文件
omplete(const Path& p, const Path& base = initial_path ()); 以base以基，p作为相对路径，返回其完整路径
create_directories(const Path & p); 建立路径建立文件夹

4.基本案例

案例1

#include <boost/filesystem.hpp>
#include <string>
 
int main()
{
    boost::filesystem::path path("/test/test1");   //初始化
    boost::filesystem::path old_cpath = boost::filesystem::current_path(); //取得当前程序所在文件夹
    boost::filesystem::path parent_path = old_cpath.parent_path();//取old_cpath的上一层父文件夹路径
    boost::filesystem::path file_path = old_cpath / "file"; //path支持重载/运算符
    if(boost::filesystem::exists(file_path)){  //推断文件存在性
        std::string strPath = file_path.string();
        int x = 1;
    } else {
        //文件夹不存在;
        boost::filesystem::create_directory(file_path);  //文件夹不存在。创建
    }
    bool bIsDirectory = boost::filesystem::is_directory(file_path); //推断file_path是否为文件夹
    boost::filesystem::recursive_directory_iterator beg_iter(file_path);
    boost::filesystem::recursive_directory_iterator end_iter;
    for (; beg_iter != end_iter; ++beg_iter) {
        if (boost::filesystem::is_directory(*beg_iter)){
             continue;
        }else{
            std::string strPath = beg_iter->path().string();  //遍历出来的文件名称
            int x=1;
        }
    }
    boost::filesystem::path new_file_path = file_path / "test.txt";
    if(boost::filesystem::is_regular_file(new_file_path)){	//推断是否为普通文件
        UINT sizefile = boost::filesystem::file_size(new_file_path);  //文件大小(字节)
        int x =1;
    }
    boost::filesystem::remove(new_file_path);//删除文件new_file_path
}

案例2

  std::string map_path1 = "/home/megvii/1carto_work/src/map_manager/maps/test";
  std::cout<<"map_path1:"<<map_path1<<std::endl;
  boost::filesystem::path filePath(map_path1);
  if(boost::filesystem::exists(filePath)){
    std::cout<<"目录存在:"<<std::endl;
 
    /*返回删除的文件夹和文件数,包括路径本身
     * remove_all  删除文件夹及其下全部文件
     * remove  删除文件或空文件夹
     */
    uintmax_t test = boost::filesystem::remove_all(map_path1);
    std::cout<<"删除该目录:"<<std::endl;
 
  }else{
    std::cout<<"目录不存在:"<<std::endl;
    /*文件夹不存在。创建*/
    boost::filesystem::create_directory(map_path1);
    std::cout<<"创建该目录:"<<std::endl;
  }

5. c++ 读写txt

1.小结

在这里插入图片描述

2.正常的读写

案例1

#include <fstream>
#include <ios>
#include <string>
  std::ofstream of("/home/mayun16/gtest/readme.txt",std::ios::app);
  int num =0;
  while (num<10) {
    num++;
    of<<123<<" "<<num<<" "<<"aaa"<<std::endl;
  }
  of.close();

  std::ifstream istm("/home/mayun16/gtest/readme.txt");

  char *cchar = new char[100];

  num = 0;
  while (num<10) {
    num++;
    istm.getline(cchar,20,'\n');
    std::cout<<num<<": "<<cchar<<std::endl;
    std::string sss(cchar);
    std::cout<<num<<" string: "<<sss<<std::endl;
  }

案例2

std::ofstream CSMfile_("/home/poses_saver/txt/CSM_pose.txt",std::ios::out);

void poseCSMCallback(const geometry_msgs::PoseStamped::ConstPtr& msg)
{
  CSMfile_.precision(9);
  CSMfile_ << msg->header.stamp <<" ";
  CSMfile_.precision(5);
  CSMfile_ << msg->pose.position.x<< " "
  << msg->pose.position.y << " "
  << 0 <<" "
  << msg->pose.orientation.x<<" "
  << msg->pose.orientation.y<<" "
  << msg->pose.orientation.z<<" "
  << msg->pose.orientation.w<< std::endl;
}

案例3

      std::string mark1_mark_read_path = loadMarkInMark1Path_;
      std::ifstream mark1_mark_read(mark1_mark_read_path);
      if(mark1_mark_read){
        while (!mark1_mark_read.eof()) {
          std::string str;
          std::getline(mark1_mark_read,str);
          if(!str.empty()){
            std::stringstream ss;
            ss << str;
            int id,key;
            double x,y,theta;
            ss>>id; ss>>key;
            ss>>x;ss>>y;ss>>theta;
            if(key==777){
              cartographer_ros_msgs::LandmarkEntry landmark_entry;
              landmark_entry.id = std::to_string(id);
              tf::Transform transform(tf::createQuaternionFromYaw(theta),tf::Vector3(x,y,0));
              landmark_entry.tracking_from_landmark_transform = TfTransformToGeometryPose(transform);
              landmark_list_mark1_.landmarks.push_back(landmark_entry);
            }
          }
        }
        mark_mark_read.close();

6.set list map

1.介绍

List:

可以允许重复的对象。
可以插入多个null元素。
是一个有序容器，保持了每个元素的插入顺序，输出的顺序就是插入的顺序。
常用的实现类有 ArrayList、LinkedList 和 Vector。ArrayList 最为流行，它提供了使用索引的随意访问，而 LinkedList 则对于经常需要从 List 中添加或删除元素的场合更为合适。

Set:

不允许重复对象
无序容器，你无法保证每个元素的存储顺序，TreeSet通过 Comparator 或者 Comparable维护了一个排序顺序。
只允许一个 null 元素 Set 接口最流行的几个实现类是 HashSet、LinkedHashSet 以及
TreeSet。最流行的是基于 HashMap 实现的 HashSet；TreeSet 还实现了 SortedSet 接口，因此
TreeSet 是一个根据其 compare() 和 compareTo() 的定义进行排序的有序容器。
add(value)：添加某个值，返回Set结构本身。 delete(value)：删除某个值，返回一个布尔值，表示删除是否成功。
has(value)：返回一个布尔值，表示该值是否为Set的成员。 clear()：清除所有成员，没有返回值

Map:

不是collection的子接口或者实现类。Map是一个接口。
Map 的每个 Entry 都持有两个对象，也就是一个键一个值，Map 可能会持有相同的值对象但键对象必须是唯一的。
TreeMap 也通过 Comparator 或者 Comparable 维护了一个排序顺序。
Map 里你可以拥有随意个 null 值但最多只能有一个 null 键。
Map 接口最流行的几个实现类是 HashMap、LinkedHashMap、Hashtable 和 TreeMap。（HashMap、TreeMap最常用）

2.什么场景下使用list，set，map呢？

如果你经常会使用索引来对容器中的元素进行访问，那么 List 是你的正确的选择。如果你已经知道索引了的话，那么 List 的实现类比如 ArrayList 可以提供更快速的访问,如果经常添加删除元素的，那么肯定要选择LinkedList。
如果你想容器中的元素能够按照它们插入的次序进行有序存储，那么还是 List，因为 List 是一个有序容器，它按照插入顺序进行存储。
如果你想保证插入元素的唯一性，也就是你不想有重复值的出现，那么可以选择一个 Set 的实现类，比如 HashSet、LinkedHashSet 或者 TreeSet。所有 Set 的实现类都遵循了统一约束比如唯一性，而且还提供了额外的特性比如 TreeSet 还是一个 SortedSet，所有存储于 TreeSet 中的元素可以使用 Java 里的 Comparator 或者 Comparable 进行排序。LinkedHashSet 也按照元素的插入顺序对它们进行存储。
如果你以键和值的形式进行数据存储那么 Map 是你正确的选择。你可以根据你的后续需要从 Hashtable、HashMap、TreeMap 中进行选择。

7.std :: tie、std :: make_tuple

1.两者比较

std::tie( x, y, z )
std::make_tuple( std::ref(x), std::ref(y), std::ref(z) )

两个表达式之间没有功能上的差异。tie()只是更短，而make_tuple()更通用。

make_tuple

template<class… Types> constexpr tuple<VTypes…> make_tuple(Types&&… t);
我们Ui可以decay_t为每个Ti类型研究。
然后，每个Vi中VTypes是X&如果Ui等号reference_wrapper，否则Vi是Ui。
因此std::make_tuple( std::ref(x), std::ref(y), std::ref(z) )产生了 std::tuple<X&, Y&, Z&>

#include <iostream>
#include <string>
#include <tuple>
 
int main()
{
    auto t = std::make_tuple(1, "Foo", 3.14);
    // index-based access
    std::cout << "(" << std::get<0>(t) << ", " << std::get<1>(t)
              << ", " << std::get<2>(t) << ")\n";
    std::get<0>(t) = 2；
    // type-based access
    std::cout << "(" << std::get<int>(t) << ", " << std::get<const char*>(t)
              << ", " << std::get<double>(t) << ")\n";
    // Note: std::tie and structured binding may also be used to decompose a tuple
}

2.另一方面，tie

template<class… Types> constexpr tuple<Types&…> tie(Types&… t) noexcept;

返回： tuple<Types&…>(t…)。当在一个参数t是ignore，分配的任何值到相应的元组元素没有任何效果。

因此，std::tie(x, y, z)也产生一个std::tuple<X&, Y&, Z&>。

#include <tuple>
#include <functional>

void f(std::reference_wrapper<int> x, int y, int z)
{
    std::tie(x,y,z); // type is std::tuple<std::reference_wrapper<int>&, int&, int&>
    std::make_tuple(std::ref(x),std::ref(y),std::ref(z)); // type is std::tuple<int&, int&, int&>
}

8.c++ yaml

1.CMakeList.txt中添加：

find_package(PkgConfig REQUIRED)
pkg_check_modules(YAML REQUIRED yaml-cpp)
message(STATUS "YAML=${YAML_INCLUDE_DIRS} ${YAML_LIBRARIES}")

catkin_package(
  DEPENDS
   YAML
)

include_directories( ${YAML_INCLUDE_DIRS})

target_link_libraries(${PROJECT_NAME}_node  ${YAML_LIBRARIES})

2.文件中：

#include <yaml-cpp/yaml.h>

  YAML::Node read_yaml_test;

  read_yaml_test = YAML::LoadFile("/home/mayun16/Desktop/MultiModalRobotParam/system/user_config.yaml");
  int map_id_default = read_yaml_test["map_id_default"].as<int>();
  cout<<"map_id_default: "<<map_id_default <<endl;

3.具体使用：

读

  YAML::Node config = YAML::LoadFile(yaml_path.string());
  try{
    id_ = config["id"].as<int>();
    resolution_ = config["resolution"].as<double>();
    origin_x_ = config["origin"][0].as<double>();
    origin_y_ = config["origin"][1].as<double>();
    origin_th_ = config["origin"][2].as<double>();
    negate_ = config["negate"].as<int>();
    occupied_thresh_ = config["occupied_thresh"].as<double>();
    free_thresh_ = config["free_thresh"].as<double>();
    floor_ = config["floor"].as<int>();
    name_ = config["name"].as<std::string>();
  }catch(YAML::Exception& e){
    ROS_ERROR("There are wrong parameters,%s",info_yaml_path.c_str());
    return false;
  }

写

  YAML::Node config = YAML::LoadFile(yaml_path.string());
  try{
    id_ = config["id"].as<int>();
    resolution_ = config["resolution"].as<double>();
    origin_x_ = config["origin"][0].as<double>();
    origin_y_ = config["origin"][1].as<double>();
    origin_th_ = config["origin"][2].as<double>();
    negate_ = config["negate"].as<int>();
    occupied_thresh_ = config["occupied_thresh"].as<double>();
    free_thresh_ = config["free_thresh"].as<double>();
    floor_ = config["floor"].as<int>();
    name_ = config["name"].as<std::string>();
  }catch(YAML::Exception& e){
    ROS_ERROR("There are wrong parameters,%s",info_yaml_path.c_str());
    return false;
  }

9.unordered_set 模型

unordered_set是一些容器，它们以不特定的顺序存储唯一的元素，并允许根据各自的值快速检索各个元素。

1.模板原型:

template < class Key,                        // unordered_set::key_type/value_type
           class Hash = hash<Key>,           // unordered_set::hasher
           class Pred = equal_to<Key>,       // unordered_set::key_equal
           class Alloc = allocator<Key>      // unordered_set::allocator_type
           > class unordered_set;

在unordered_set中，元素的值同时是其关键字，用于唯一标识它。键是不可变的，因此，unordered_set中的元素不能在容器中修改一次，但可以插入和删除它们。
在内部，unordered_set中的元素没有按照任何特定的顺序排序，而是根据它们的散列值组织成桶，以允许通过它们的值直接快速访问各个元素（平均具有恒定的平均时间复杂度）。
unordered_set容器的速度比设置容器的速度快，以通过它们的键访问各个元素，尽管它们对于通过元素子集的范围迭代通常效率较低。

2.容器属性

联想关联容器中的元素由它们的键引用，而不是它们在容器中的绝对位置。
无序无序容器使用散列表来组织它们的元素，这些散列表允许通过键快速访问元素。
组元素的值也是识别它的关键。
独特的钥匙 容器中没有两个元素可以具有相同的键。
分配器感知 容器使用分配器对象来动态处理其存储需求。

Capacity 容量： empyt size max_size
Iterators迭代器：begin end cbegin cend
Element lookup元素查找：find count equal_range
Modifiers修饰符：emplace emplace_hint insert erase clear swap
Buckets水桶：bucket_cout max_bucket_count bucket_size bucket
Hash policy哈希策略：hash_function max_load_factor rehash reserve
Observers:hash_function key_eq get_allocator

非成员函数重载： operators(unordered_set) swap(unordered_set)

容器中的迭代器至少是前向迭代器。C++ 11中对unordered_set描述大体如下：无序集合容器（unordered_set）是一个存储唯一(unique，即无重复）的关联容器（Associative container），容器中的元素无特别的秩序关系，该容器允许基于值的快速元素检索，同时也支持正向迭代。在一个unordered_set内部，元素不会按任何顺序排序，而是通过元素值的hash值将元素分组放置到各个槽(Bucker，也可以译为“桶”），这样就能通过元素值快速访问各个对应的元素（均摊耗时为O（1））。原型中的Key代表要存储的类型，而hash也就是你的hash函数，equal_to用来判断两个元素是否相等，allocator是内存的分配策略。一般情况下，我们只关心hash和equal_to参数。

hash

hash通过相应的hash函数，将传入的参数转换为一个size_t类型值，然后用该值对当前hashtable的bucket取模算得其对应的hash值。

而C++标准库，为我们提供了基本数据类型的hash函数：

整型值：bool、char、unsigned char、wchar_t、char16_t、char32_t、short、int、long、long long、unsigned short、unsigned int、unsigned long、unsigned long long。上述的基本数据类型，其标准库提供的hash函数只是简单将其值转换为一个size_t类型值，具体可以参考标准库functional_hash.h头文件，如下所示：

/// Primary class template hash.  
  template<typename _Tp>  
    struct hash;  
  
  /// Partial specializations for pointer types.  
  template<typename _Tp>  
    struct hash<_Tp*> : public __hash_base<size_t, _Tp*>  
    {  
      size_t  
      operator()(_Tp* __p) const noexcept  
      { return reinterpret_cast<size_t>(__p); }  
    };  
  
  // Explicit specializations for integer types.  
#define _Cxx_hashtable_define_trivial_hash(_Tp)     \  
  template<>                      \  
    struct hash<_Tp> : public __hash_base<size_t, _Tp>  \  
    {                                                   \  
      size_t                                            \  
      operator()(_Tp __val) const noexcept              \  
      { return static_cast<size_t>(__val); }            \  
    };  
  
  /// Explicit specialization for bool.  
  _Cxx_hashtable_define_trivial_hash(bool)  
  
  /// Explicit specialization for char.  
  _Cxx_hashtable_define_trivial_hash(char)  
  
  /// Explicit specialization for signed char.  
  _Cxx_hashtable_define_trivial_hash(signed char)  
  
  /// Explicit specialization for unsigned char.  
  _Cxx_hashtable_define_trivial_hash(unsigned char)  
  
  /// Explicit specialization for wchar_t.  
  _Cxx_hashtable_define_trivial_hash(wchar_t)  
  
  /// Explicit specialization for char16_t.  
  _Cxx_hashtable_define_trivial_hash(char16_t)  
  
  /// Explicit specialization for char32_t.  
  _Cxx_hashtable_define_trivial_hash(char32_t)  
  
  /// Explicit specialization for short.  
  _Cxx_hashtable_define_trivial_hash(short)  
  
  /// Explicit specialization for int.  
  _Cxx_hashtable_define_trivial_hash(int)  
  
  /// Explicit specialization for long.  
  _Cxx_hashtable_define_trivial_hash(long)  
  
  /// Explicit specialization for long long.  
  _Cxx_hashtable_define_trivial_hash(long long)  
  
  /// Explicit specialization for unsigned short.  
  _Cxx_hashtable_define_trivial_hash(unsigned short)  
  
  /// Explicit specialization for unsigned int.  
  _Cxx_hashtable_define_trivial_hash(unsigned int)  
  
  /// Explicit specialization for unsigned long.  
  _Cxx_hashtable_define_trivial_hash(unsigned long)  
  
  /// Explicit specialization for unsigned long long.  
  _Cxx_hashtable_define_trivial_hash(unsigned long long)

对于指针类型，标准库只是单一将地址转换为一个size_t值作为hash值，这里特别需要注意的是char *类型的指针，其标准库提供的hash函数只是将指针所指地址转换为一个sieze_t值，如果，你需要用char *所指的内容做hash，那么，你需要自己写hash函数或者调用系统提供的hash。
2.标准库为string类型对象提供了一个hash函数，即：Murmur hash，。对于float、double、long double标准库也有相应的hash函数，这里，不做过多的解释，相应的可以参看functional_hash.h头文件。

上述只是介绍了基本数据类型，而在实际应用中，有时，我们需要使用自己写的hash函数，那怎么自定义hash函数？参考标准库基本数据类型的hash函数，我们会发现这些hash函数有个共同的特点：通过定义函数对象，实现相应的hash函数，这也就意味我们可以通过自定义相应的函数对象，来实现自定义hash函数。比如：已知平面上有N，每个点的x轴、y轴范围为[0，100]，现在需要统计有多少个不同点？hash函数设计为：将每个点的x、y值看成是101进制，如下所示:

#include<bits\stdc++.h>  
using namespace std;  
struct myHash   
{  
    size_t operator()(pair<int, int> __val) const  
    {  
        return static_cast<size_t>(__val.first * 101 + __val.second);  
    }  
};  
int main()  
{  
    unordered_set<pair<int, int>, myHash> S;  
    int x, y;  
    while (cin >> x >> y)  
        S.insert(make_pair(x, y));  
    for (auto it = S.begin(); it != S.end(); ++it)  
        cout << it->first << " " << it->second << endl;  
    return 0;  
}

equal_to

该参数用于实现比较两个关键字是否相等，至于为什么需要这个参数？这里做点解释，前面我们说过，当不同关键字，通过hash函数，可能会得到相同的关键字值，每当我们在unordered_set里面做数据插入、删除时，由于unordered_set关键字唯一性，所以我们得确保唯一性。标准库定义了基本类型的比较函数，而对于自定义的数据类型，我们需要自定义比较函数。这里有两种方法:重载==操作符和使用函数对象，下面是STL中实现equal_to的源代码：

template<typename _Arg, typename _Result>  
    struct unary_function  
    {  
      /// @c argument_type is the type of the argument  
      typedef _Arg  argument_type;     
  
      /// @c result_type is the return type  
      typedef _Result   result_type;    
    };  
template<typename _Tp>  
    struct equal_to : public binary_function<_Tp, _Tp, bool>  
    {  
      bool  
      operator()(const _Tp& __x, const _Tp& __y) const  
      { return __x == __y; }  
    };

3.扩容与缩容

在vector中，每当我们插入一个新元素时，如果当前的容量（capacity)已不足，需要向系统申请一个更大的空间，然后将原始数据拷贝到新空间中。这种现象在unordered_set中也存在，比如当前的表长为100，而真实存在表中的数据已经大于1000个元素，此时，每个bucker均摊有10个元素，这样就会影响到unordered_set的存取效率，而标准库通过采用某种策略来对当前空间进行扩容，以此来提高存取效率。
当然，这里也存在缩容，原理和扩容类似，不过，需要注意的是，每当unordered_set内部进行一次扩容或者缩容，都需要对表中的数据重新计算，也就是说，扩容或者缩容的时间复杂度至少为O(n)。
code：

/ unordered_set::find  
#include <iostream>  
#include <string>  
#include <unordered_set>  
  
int main ()  
{  
  std::unordered_set<std::string> myset = { "red","green","blue" };  
  
  std::string input;  
  std::cout << "color? ";  
  getline (std::cin,input);  
  
  std::unordered_set<std::string>::const_iterator got = myset.find (input);  
  
  if ( got == myset.end() )  
    std::cout << "not found in myset";  
  else  
    std::cout << *got << " is in myset";  
  
  std::cout << std::endl;  
  
  return 0;  
}

10.指针学习总结

指针的值是一个地址，用来指向某个变量、数组、常量的首地址。

/*首先是指针的定义*/
int p;//p是一个整型变量。
int *p;//p是一个指针变量，指向整型变量。
int *p[];/*p是一个数组，数组里存储的是指向整型变量的指针*/
int (*p)[];/*p是一个指针，指向整型数组的首地址。*/
int *p();/*p是一个函数，返回值是整型指针*/
int (*p)();/*p是一个指针，指向一个返回值为整型的函数*/
  
/*指针的赋值*/
int a,b[10];
int fun();
int *p=&a;//等价于 int *p;p=&a;
 
p=b//p指向b[0],p+n指向b[n];
 
int (*ptr)();
ptr=fun;//ptr 指向fun()的入口地址

11.四舍五入

round, roundf, roundl - 四舍五入取整，求最接近 x 的整数
函数原型：

double round(double x);	 	
float roundf(float x);	 		 
long double roundl(long double x);		 
float round(float x);	 	 	 	
long double round(long double x);

头文件：#include <cmath>
命名空间：std
参数：x：浮点数
取整之后的浮点数，是一个最接近 x 的整数值，从坐标轴上看，返回值是与 x 重合或在 x 的两侧与 x 距离最近的整数，
如果有两个整数和 x 的距离相等，即 x 的小数部分正好等于 0.5 的时候，取绝对值大的那个整数，
从字面上看，就是 “四舍五入”，只要小数点后面第一位数字是 5 或者大于 5 就进位，小于 5 就舍去。
std::round 与 System::Math::RoundTo 函数的区别，在有两个整数和 x 的距离相等的时候：
round 取绝对值大的整数，即 “四舍五入”；
RoundTo 取偶数，即 “四舍六入五成双”，称为 Banker’s Rounding 规则 (五后有数入、五后无数凑偶数)；
round, roundf, roundl 是一组 C++ 11 新标准函数，在 C++ Builder 里面可以使用 System::Math::RoundTo 函数替代，虽然有细微的差别，而且在实际应用当中，更推荐使用 “四舍六入五成双” 的 Banker’s Rounding 规则的 System::Math::RoundTo 函数。

12 std::unique_ptr、shared_ptr

class a;
std::unique_ptr<A> (new A());

简易使用

//申明
std::unique_ptr<RangeDataCollatorNew> range_data_collator_ptr_;  ///< 激光数据同步对象
std::shared_ptr<PoseExtrapolatorSimple>  pose_extrapolator_ptr_;    ///< 位姿推算器对象

//初始化
range_data_collator_ptr_ = std::unique_ptr<RangeDataCollatorNew>(new RangeDataCollatorNew());
pose_extrapolator_ptr_ = std::make_shared<PoseExtrapolatorSimple>(kPoseQueueDuration, kGravityTimeConstant);

13. 【C++ 异常】jump to case label [-fpermissive]

13.1 问题代码

int main()
{
  int test = 2;
  switch(test)
  {
    case 1:
      int i = 1;  // i初始化后，一直存在，直到switch结束
      cout << i;
      break;
    case 2:
      cout << i;  // i未被初始化
      break;
    default:
      cout << "error" << endl;
  }
}

#报错信息如下
//test.cpp: In function 'int main()':
//test.cpp: error: jump to case label [-fpermissive]
//   case 2:
//        ^
//test.cpp: error:   crosses initialization of 'int i'
//    int b = 1;
//test.cpp: error: jump to case label [-fpermissive]
//   default:
//   ^
//test.cpp:11:8: error:   crosses initialization of 'int i'
//    int b = 1;

13. 2 说明

从上面的代码中可以看出，因为switch中没有单独的区域块来限定变量i的声明周期，所以变量的作用域是初始化点到switch的结尾处。这里由于我们无法确定其他case中是否会使用到这种变量，使用之前变量是否被初始化，所以编译器会报错。例如：test值为2，直接执行case 2的话，未定义变量就会出异常。这也是编译器报错crosses initialization的原因。
经过检验发现，无论其他分支是否包含定义的变量，只要case中带变量不带括号，编译器都会报错。

13.3修改方法

1、【缩小作用域】将case 1的代码用{ }括起来，设定清楚变量i的作用域，避免其他case访问
2、【扩大作用域】将变量i放到switch外部，switch中的每个case都可以访问

13.4 深入了解

switch语句是goto语句的一种，所以goto具备相同的性质，下述的goto语句不会被执行，变量i一定会被定义，但是会报跟上面一样的错误。这说明goto与标签之间，不能出现变量。变量必须出现在goto之前或标签之后。

13 undef

修改已经宏定义的符号常量的值：

#include <stdio.h>
int main( void )
{
#define MAX 200
    printf("MAX= %d\n",MAX);
#undef MAX
#define MAX 300
    printf("MAX= %d\n",MAX);
    return 0;
}

#undef　　#undef 是在后面取消以前定义的宏定义
该指令的形式为 :
　　#undef 标识符

其中，标识符是一个宏名称。如果标识符当前没有被定义成一个宏名称，那么就会忽略该指令。
一旦定义预处理器标识符，它将保持已定义状态且在作用域内，直到程序结束或者使用#undef 指令取消定义。

14.c++14 std::make_unique

template <class T>
struct _Unique_if {
  typedef std::unique_ptr<T> _Single_object;
};

template <class T>
struct _Unique_if<T[]> {
  typedef std::unique_ptr<T[]> _Unknown_bound;
};

template <class T, size_t N>
struct _Unique_if<T[N]> {
  typedef void _Known_bound;
};

template <class T, class... Args>
typename _Unique_if<T>::_Single_object make_unique(Args&&... args) {
  return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
}

template <class T>
typename _Unique_if<T>::_Unknown_bound make_unique(size_t n) {
  typedef typename std::remove_extent<T>::type U;
  return std::unique_ptr<T>(new U[n]());
}

template <class T, class... Args>
typename _Unique_if<T>::_Known_bound make_unique(Args&&...) = delete;

15 泛型模板函数 undefined reference to

15.1 问题

一类是链接的问题

链接时缺失了相关目标文件（.o）
链接时缺少相关的库文件（.a/.so）
链接的库文件中又使用了另一个库文件
多个库文件链接顺序问题
定义与实现不一致
在C++代码中链接C语言的库

另一类是C++的name mangling技术的问题

15.2 解决

1. 把实现方法直接写在头文件里
2. 将实现方法全写在另一个文件里，然后在头文件的结尾包含该文件
3. 在头文件对应的实现文件里添加具体类型的函数声明，

15.3 案例

在.cc中申明

template bool SensorChecks::AddSensorData(const nav_msgs::Odometry& sensor_data);
template bool SensorChecks::AddSensorData(const sensor_msgs::Imu& sensor_data);
template bool SensorChecks::AddSensorData(const sensor_msgs::LaserScan& sensor_data);

template <typename DataType>
bool SensorChecks::AddSensorData(const DataType& sensor_data){
  const std::string & frame_id = sensor_data.header.frame_id;
  if(map_sub_topics_check_.count(frame_id) == 0){
    map_sub_topics_check_.emplace(frame_id,SensorCheck());
    map_sub_topics_check_.at(frame_id).SaveReportPath(true,save_check_result_path_);
  }
  CHECK_NE(map_sub_topics_check_.count(frame_id),0);
  return map_sub_topics_check_.at(frame_id).AddSensorData(sensor_data);
}

直接写在头文件 .h中

template <typename DataType>
bool SensorChecks::AddSensorData(const DataType& sensor_data){
  const std::string & frame_id = sensor_data.header.frame_id;
  if(map_sub_topics_check_.count(frame_id) == 0){
    map_sub_topics_check_.emplace(frame_id,SensorCheck());
    map_sub_topics_check_.at(frame_id).SaveReportPath(true,save_check_result_path_);
  }
  CHECK_NE(map_sub_topics_check_.count(frame_id),0);
  return map_sub_topics_check_.at(frame_id).AddSensorData(sensor_data);
}

将文件引入头文件

/*实现方法写在其它文件里，然后包含在头文件的结尾 */
template<typename T>
void AddSensorData(T &a, T &b);
#include "AddSensorData.cc"

16. vector

16.1 vector 简介

作用：它能够像容器一样存放各种类型的对象，简单地说，vector是一个能够存放任意类型的动态数组，能够增加和压缩数据。
vector在C++标准模板库中的部分内容，它是一个多功能的，能够操作多种数据结构和算法的模板类和函数库。

容器特点

序列容器中的元素按严格的线性顺序排序。各个元素按其在此序列中的位置进行访问。
甚至可以通过指针算术直接访问序列中的任何元素，并在序列末尾提供相对快速的元素添加/删除。
容器使用分配器对象动态处理其存储需求。

16.2问题

赋值
将一个vector的内容赋值给另一个vector

1、声明
vector v1(v2);
2、将两个容器内的元素交换，需要构建临时对象，一个拷贝构造，两次赋值操作。
vector v1();v1.swap(v2);
3、将v2赋值给v1 但会清除掉v1以前的内容
v1.assign(v2.begin(), v2.end());
4、声明迭代器
vector::iterator it;
for(it = v2.begin();it!=v2.end();++it){//遍历v2,赋值给v1 效率慢
v1.push_back(it); }
5、等号赋值，最简单
v1 = v2
6、追加，将一个容器中的内容追加到另一个容器的后面：
std::vector v1, v2 ;
v1.insert(v1.end(), v2.begin(), v2.end());

2.2 删除

iterator erase(iterator it):删除向量中迭代器指向元素
iterator erase(iterator first,iterator last):删除向量中[first,last)中元素
void pop_back():删除向量中最后一个元素
void clear():清空向量中所有元素

// erasing from vector
#include <iostream>
#include <vector>

int main ()
{
  std::vector<int> myvector;

  // set some values (from 1 to 10)
  for (int i=1; i<=10; i++) myvector.push_back(i);

  // erase the 6th element
  myvector.erase (myvector.begin()+5);
  
  // erase the first 3 elements:
  myvector.erase (myvector.begin(),myvector.begin()+3);
  std::cout << "myvector contains:";
  for (unsigned i=0; i<myvector.size(); ++i)
    std::cout << ' ' << myvector[i];
  std::cout << '\n';
  return 0;
}

2.3 技巧

如果你要表示的向量长度较长（需要为向量内部保存很多数），容易导致内存泄漏，而且效率会很低；
Vector作为函数的参数或者返回值时，需要注意它的写法：
double Distance(vector&a, vector&b) 其中的“&”绝对不能少！！！

释放vector的内存

是的，对于数据量很小的vector，完全没必要自己进行主动的释放，因为其对程序的效率几乎没有影响。但是当vector中存入大量的数据且都数据进行了一些操作，比如删除后，如果我们能积极主动的去释放内存，那么是非常有意义的。
std::vector::clear()
- Removes all elements from the vector (which are destroyed), leaving the container with a size of 0.
- 英文中提到的是size=0，而非capacity。clear后，size变为了0，capacity没有变化。再读一读clear的英文描述：
- `A reallocation is not guaranteed to happen, and the vector capacity is not guaranteed to change due to calling this function. A typical alternative that forces a reallocation is to use swap:
vector().swap(x); // clear x reallocating
- vector().swap(v);
- swap之后，不仅仅是size变化了，capacity也是变化了。
shrink_to_fit()
- 如果clear后在调用shrink_to_fit()也一样
- 所以不用以为只有swap替代clear才能正确释放vector的内存，C++11推出了shrink_to_fit方法，也可以达到目的。

17 STL set,deque,queue,map

17.1 std::set

集合是按照特定顺序存储唯一元素的容器。
在一个集合中，元素的值还可以标识它（该值本身是T类型的键），并且每个值都必须是唯一的。集合中元素的值不能一次在容器中修改（元素始终为const），但可以将其插入容器或从容器中删除。
在内部，集合中的元素始终按照其内部比较对象（类型为Compare）指示的特定严格弱排序标准进行排序。
set 容器通常比unordered_set容器通过键访问单个元素的速度慢，但是它们允许基于子集的顺序直接迭代子集。
set 通常实现为二进制搜索树。

容器属性

Associative：关联容器中的元素由其键而不是其在容器中的绝对位置来引用。
Ordered：容器中的元素始终严格遵守顺序。所有插入的元素均按此顺序分配位置。
set：元素的值也是用于标识它的键。
Unique keys：容器中没有两个元素可以具有等效键。
Allocator-aware：容器使用分配器对象动态处理其存储需求。

1.2 成员函数

操作	相关
operator=	复制容器内容（公共成员函数）
Iterators:
begin	Return iterator to beginning (public member function )
end	Return iterator to end (public member function )
rbegin	Return reverse iterator to reverse beginning (public member function )
rend	Return reverse iterator to reverse end (public member function )
cbegin	Return const_iterator to beginning (public member function )
cend	Return const_iterator to end (public member function )
crbegin	Return const_reverse_iterator to reverse beginning (public member function )
crend	Return const_reverse_iterator to reverse end (public member function )
Capacity:
empty	Test whether container is empty (public member function )
size	Return container size (public member function )
max_size	Return maximum size (public member function )
Modifiers:
insert	Insert element (public member function )
erase	Erase elements (public member function )
swap	Swap content (public member function )
clear	Clear content (public member function )
emplace	Construct and insert element (public member function )
emplace_hint	Construct and insert element with hint (public member function )
Observers:
key_comp	Return comparison object (public member function )
value_comp	Return comparison object (public member function )
Operations:
find	Get iterator to element (public member function )
count	)因为集合容器中的所有元素都是唯一的，所以该函数只能返回1（如果找到了元素）或零（否则）
lower_bound	Return iterator to lower bound (public member function )
upper_bound	Return iterator to upper bound (public member function )
equal_range	Get range of equal elements (public member function )

unordered_set

无序集合是不按特定顺序存储唯一元素的容器，并允许根据其值快速检索单个元素。
在unordered_set中，元素的值同时是其键，可以唯一地标识它。键是不可变的，因此，不能在容器中一次修改unordered_set中的元素-尽管可以将它们插入和删除。
在内部，unordered_set中的元素未按任何特定顺序排序，而是根据其哈希值组织到存储桶中，以允许直接通过其值快速访问各个元素（平均时间常数平均保持不变）。
尽管unordered_set容器通过它们的键访问单个元素的速度要比set容器快，但是通过它们的元素子集进行范围迭代通常效率较低。

unordered_set与set差异函数

函数	说明
count	用特定键计数元素，不止0,1

17.2 deque函数：

单向队列(一端操作)：Queue
双向队列（两端操作）：Deque

deque容器为一个给定类型的元素进行线性处理，像向量一样，它能够快速地随机访问任一个元素，并且能够高效地插入和删除容器的尾部元素。但它又与vector不同，deque支持高效插入和删除容器的头部元素，因此也叫做双端队列。deque类常用的函数如下。

构造函数

deque():创建一个空deque
deque(int nSize):创建一个deque,元素个数为nSize
deque(int nSize,const T& t):创建一个deque,元素个数为nSize,且值均为t
deque(const deque &):复制构造函数

增加函数

void push_front(const T& x):双端队列头部增加一个元素X
void push_back(const T& x):双端队列尾部增加一个元素x
iterator insert(iterator it,const T& x):双端队列中某一元素前增加一个元素x
void insert(iterator it,int n,const T& x):双端队列中某一元素前增加n个相同的元素x
void insert(iterator it,const_iterator first,const_iteratorlast):双端队列中某一元素前插入另一个相同类型向量的[forst,last)间的数据

删除函数

Iterator erase(iterator it):删除双端队列中的某一个元素
Iterator erase(iterator first,iterator last):删除双端队列中[first,last）中的元素
void pop_front():删除双端队列中最前一个元素
void pop_back():删除双端队列中最后一个元素
void clear():清空双端队列中最后一个元素

遍历函数

reference at(int pos):返回pos位置元素的引用
reference front():返回首元素的引用
reference back():返回尾元素的引用
iterator begin():返回向量头指针，指向第一个元素
iterator end():返回指向向量中最后一个元素下一个元素的指针（不包含在向量中
reverse_iterator rbegin():反向迭代器，指向最后一个元素
reverse_iterator rend():反向迭代器，指向第一个元素的前一个元素

判断函数

bool empty() const:向量是否为空，若true,则向量中无元素

大小函数

Int size() const:返回向量中元素的个数
int max_size() const:返回最大可允许的双端对了元素数量值

其他函数
void swap(deque&):交换两个同类型向量的数据
void assign(int n,const T& x):向量中第n个元素的值设置为x

17.3. map、unordered_map

map
std::map 类模板：

template < class Key,                                     // map::key_type
           class T,                                       // map::mapped_type
           class Compare = less<Key>,                     // map::key_compare
           class Alloc = allocator<pair<const Key,T> >    // map::allocator_type
           > class map;

在 std::map 中，Key 和 T 一起组成了 std::map 的 value_type：

typedef pair<const Key, T> value_type;

类型成员	定义
key_type	第一个模板参数（Key）
mapped_type	第二个模板参数（T）
value_type	pair<const key_type,mapped_type>
key_compare	第三个模板参数（Compare）

关联性：std::map 是一个关联容器，其中的元素根据键来引用，而不是根据索引来引用。
有序性：在内部，std::map 中的元素总是按照其内部的比较器（比较器类型由Compare类型参数指定）指示的特定严格弱序标准按其键排序。
唯一性：std::map 中的元素的键是唯一的。
std::map 通常由二叉搜索树实现。

构造案例

// constructing maps
#include <iostream>
#include <map>

// 比较器1
bool fncomp (char lhs, char rhs) { 
	return lhs < rhs; 
}

// 比较器2
struct classcomp {
	bool operator() (const char& lhs, const char& rhs) const {
		return lhs<rhs;
	}
};

int main () {
	// 默认构造，构造一个空的map
	std::map<char,int> first;
	
	first['a']=10;
	first['b']=30;
	first['c']=50;
	first['d']=70;
	
	// 由一对范围迭代器指定输入
	std::map<char,int> second (first.begin(), first.end());
	
	// 复制构造
	std::map<char,int> third (second);
	
	// 指定比较器：使用类
	std::map<char, int, classcomp> fourth;                 // class as Compare
	
	// 指定比较器：使用函数指针
	bool(*fn_pt)(char, char) = fncomp;
	std::map<char, int, bool(*)(char,char)> fifth (fn_pt); // function pointer as Compare
	
	return 0;
}

unordered_map

关联性：通过key去检索value，而不是通过绝对地址（和顺序容器不同）
无序性：使用hash表存储，内部无序
Map : 每个值对应一个键值
键唯一性：不存在两个元素的键一样
动态内存管理：使用内存管理模型来动态管理所需要的内存空间

unordered_map<const Key, T> map;

迭代器

unordered_map<Key,T>::iterator it;
(*it).first;             // the key value (of type Key)
(*it).second;            // the mapped value (of type T)
(*it);                   // the "element value" (of type pair<const Key,T>)

17 fill ,fill_n

填充”功能为范围[begin，end]中的所有元素分配值“ val”，其中“ begin”是初始位置，“ end”是最后位置。

17.1 fill

头文件

algorithm

声明

template< class ForwardIt, class T >
void fill( ForwardIt first, ForwardIt last, const T& value );

ForwardIt 是一种迭代器，支持的数据类型包括数组、vector等。此外，对于超出范围的输入，是一种未定义的操作，结果视编译器而异。

参数

first, last :所需要修改元素的范围
value: 所需要修改的值

函数实现

template< class ForwardIt, class T >
void fill(ForwardIt first, ForwardIt last, const T& value)
{
    for (; first != last; ++first) {
        *first = value;
    }
}

案例

/*
* @Author:Jason.Lee
* @Date: 2018-7-3 
*/ 

#include<algorithm>
#include<iostream>
#include<iterator>

using namespace std;

int main(){
    vector<int> vect(8); 
    // calling fill to initialize values in the 
    // range to 4 
    fill(vect.begin() + 2, vect.end(), 4); 
    copy(vect.begin(),vect.end(),ostream_iterator<int>(cout," "));
    return 0;
}

17.2. fill_n

fill_n函数与fill在功能上并没有太大不同，应用场景有所不同。
fill是将整块数据“从头到尾”进行赋值，而fill_n是将数据的n个元素进行赋值，两者其实都能实现相同的效果。

头文件

Defined in header

声明

template< class OutputIt, class Size, class T >
void fill_n( OutputIt first, Size count, const T& value );

template< class OutputIt, class Size, class T >
OutputIt fill_n( OutputIt first, Size count, const T& value );

template< class OutputIt, class Size, class T >
constexpr OutputIt fill_n( OutputIt first, Size count, const T& value );

template< class ExecutionPolicy, class ForwardIt, class Size, class T >
ForwardIt fill_n( ExecutionPolicy&& policy, ForwardIt first, Size count, const T& value );

参数

first - 要修改的元素范围的开始
count - 要修改的元素数
value - 要分配的值
policy - 要使用的执行策略。有关详细信息，请参见执行策略。

返回值
如果count> 0，则迭代最后分配的元素之后的迭代器，否则迭代第一个。

异常
具有名为ExecutionPolicy的模板参数的重载报告错误，如下所示：

如果作为算法一部分调用的函数的执行引发异常，并且ExecutionPolicy是标准策略之一，则将调用std :: terminate。对于任何其他ExecutionPolicy，该行为都是实现定义的。
如果算法无法分配内存，则会抛出std :: bad_alloc。

案例

#include <algorithm>
#include <vector>
#include <iostream>
#include <iterator>
 
int main()
{
    std::vector<int> v1{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
 
    std::fill_n(v1.begin(), 5, -1);
 
    std::copy(begin(v1), end(v1), std::ostream_iterator<int>(std::cout, " "));
    std::cout << "\n";
}

18 queue vs deque

二者差异：

queue可以访问两端但是只能修改队头
而deque可以访问两端并且可以在队首和队尾删除和插入元素

queue

queue 从队首弹出，先入先出

并且queue只能从队首删除元素,但是两端都能访问。

queue<int>q；  //创建一个int型空队列q
q.empty（）；  // 判断队列是否为空，为空返回true
q.push（s）；  // 将变量s从队尾入队
q.pop（）；    // 将队头元素弹出
q.front（）；  // 只返回队头元素
q.back（）；  // 只返回队尾元素
q.size（）  //返回队列中元素个数

deque

deque双端队列的操作（可以在队头队尾进行入队出队操作）

deque<int> dq； // 创建一个数双端队列dq
dq.empty（）； // 判断队列是否为空，为空返回true
dq.push_front（s）； // 将s从队头入队
dq.push_back（s）； // 将s从队尾入队，和普通队列方式一样
dq.front（）； // 只返回队头元素
dq.back（）； // 只返回队尾元素
dq.pop_front（）； // 将队头元素弹出
dq.pop_back； // 将队尾元素弹出
dq.clear（）； // 将队列清空

19 遍历

深度优先遍历(Depth First Search, 简称 DFS) 与广度优先遍历(Breath First Search, 简称 BFS))是图论中两种非常重要的算法，生产上广泛用于拓扑排序，寻路(走迷宫)，搜索引擎，爬虫等，也频繁出现在 leetcode，高频面试题中。

深度、广度概念

深度优先遍历 DFS
- 主要思路是从图中一个未访问的顶点 V 开始，沿着一条路一直走到底，然后从这条路尽头的节点回退到上一个节点，再从另一条路开始走到底…，不断递归重复此过程，直到所有的顶点都遍历完成，它的特点是不撞南墙不回头，先走完一条路，再换一条路继续走。
- 即：我们选择一条支路，尽可能不断地深入，如果遇到死路就往回退，回退过程中如果遇到没探索过的支路，就进入该支路继续深入。
- 像这样先深入探索，走到头再回退寻找其他出路的遍历方式，就叫做深度优先遍历（DFS）。
广度优先遍历 BFS
- 首先把起点相邻的几个顶点遍历完，然后去遍历稍微远的（隔一层）的顶点，然后再去玩遍历更远一些（隔两层）的顶点…
- 像这样一层一层由内而外的遍历方式，就叫做广度优先遍历（BFS）。

深度、广度实现

深度优先遍历的关键在于回溯，广度优先遍历的关键在于重放。
深度优先遍历的实现：
- 回溯是什么意思呢？回溯顾名思义，就是自后向前，追溯曾经走过的路径。
- 要想实现回溯，可以利用栈的先入后出特性，也可以采用递归的方式（因为递归本身就是基于方法调用栈来实现）。
广度优先遍历的实现
- 回溯与重放是完全相反的过程。
- 把遍历过的顶点按照之前的遍历顺序重新回顾，就叫做重放。同样的，要实现重放也需要额外的存储空间，可以利用队列的先入先出特性来实现。

二者对比

二叉树的深度优先遍历的非递归的通用做法是采用栈，广度优先遍历的非递归的通用做法是采用队列。
深度优先遍历：对每一个可能的分支路径深入到不能再深入为止，而且每个结点只能访问一次。要特别注意的是，二叉树的深度优先遍历比较特殊，可以细分为先序遍历、中序遍历、后序遍历。
广度优先遍历：又叫层次遍历，从上往下对每一层依次访问，在每一层中，从左往右（也可以从右往左）访问结点，访问完一层就进入下一层，直到没有结点可以访问为止。
深度优先搜素算法：不全部保留结点，占用空间少；有回溯操作(即有入栈、出栈操作)，运行速度慢。—— 储存空间小，运行慢
广度优先搜索算法：保留全部结点，占用空间大；无回溯操作(即无入栈、出栈操作)，运行速度快。—— 存储空间大，运行快

经验：

通常深度优先搜索法不全部保留结点，扩展完的结点从数据库中弹出删去，这样，一般在数据库中存储的结点数就是深度值，因此它占用空间较少。所以，当搜索树的结点较多，用其它方法易产生内存溢出时，深度优先搜索不失为一种有效的求解方法。
- 深度优先搜索通常用于模拟游戏（以及现实世界中类似游戏的情况）。在典型的游戏中，您可以选择几种可能的操作之一。每种选择都会导致进一步的选择，每种选择都会导致进一步的选择，以此类推，形成一种不断扩展的树形可能性图。
广度优先搜索算法，一般需存储产生的所有结点，占用的存储空间要比深度优先搜索大得多，因此，程序设计中，必须考虑溢出和节省内存空间的问题。但广度优先搜索法一般无回溯操作，即入栈和出栈的操作，所以运行速度比深度优先搜索要快些。
- 广度优先搜索可用于在像对等网络中找到邻居节点，如BitTorrent，用于查找附近位置的GPS系统，用于查找指定距离内的人的社交网站以及类似的东西。