namespace std{
    template <typename T, size_t N>  
    class array;
    }

std::array<double, 10> values;
std::array<double, 10> values {};
std::array<double, 10> values {0.5,1.0,1.5,,2.0};

#include <iostream>
#include <array>
using namespace std;

int main(){    
    std::array<int, 4> values{};        
    for (int i = 0; i < values.size(); i++)
     {        
        values.at(i) = i;    
     }        
     cout << get<3>(values) << endl;
     if (!values.empty()) 
     {        
        for (auto val = values.begin(); val < values.end(); val++) 
        {            
            cout << *val << " ";        
        }    
    }
}

  
  // 类模板 array

template<class T, size_t N> struct array;

  //std::array<int,6> data = { 1, 2, 4, 5, 5, 6 };
//元素访问
  reference at( size_type pos );
  data.at(1);

  //访问指定的元素，同时进行越界检查
reference operator[]( size_type pos );
  data[1];

  //访问第一个元素
reference front();

  //访问最后一个元素
reference back();

  //返回指向内存中数组第一个元素的指针
T* data();

template <class T, class Alloc = alloc, size_t BufSize = 0>
class deque {
protected:
   typedef T** map_pointer; // map 是指针的指针
   map_pointer map; // 指向 map 的指针
   size_t map_size; // map 的大小
   iterator start; // 指向第一个缓冲区的第一个元素
   iterator finish; // 指向最后一个缓冲区的最后一个元素
};

deque<T> deqT; //默认构造形式
deque(beg, end);//构造函数将[区间中的元素拷贝给本身。
deque(n, elem); //构造函数将n个elem拷贝给本身。
deque(const deque &deq);   //拷贝构造函数

deque& operator=(const deque &deq);//重载等号操作符
assign(beg, end);//将区间中的数据拷贝赋值给本身。
assign(n, elem);//将n个elem拷贝赋值给本身。

deque.empty();
deque.size();
deque.resize(num);
deque.resize(num, elem);

at(int idx);
operator[];
front(); 
back();

push_back(elem);
push_front(elem);
pop_back();
pop_front();

insert(pos,elem);
insert(pos,n,elem);
insert(pos,beg,end);
clear();
erase(beg,end);
erase(pos);

push(elem);//往队尾添加元素
pop();//从队头移除第一个元素
back();
front();

push(elem);//向栈顶添加元素
pop();//从栈顶移除第一个元素
top();//返回栈顶元素

template<
    class Key,
    class Compare = std::less<Key>,
> class set;
//用比较函数 比较 (Compare) 进行排序。搜索、移除和插入拥有对数复杂度。 

#include <iostream>
#include <set>
using namespace std;
struct song
{
  int m_id;
  int m_hot;
  song(int id,int hot)
  {

      this->m_id = id;
      this->m_hot = hot;
  }
  /*
  bool operator<(const struct song & right)const   //重载<运算符
  {
      if(this->m_id == right.m_id)     //根据id去重
          return false;
      else
      {
          if(this->m_hot != right.m_hot)
          {
              return this->m_hot > right.m_hot;      //降序
          }
          else
          {
              return this->m_id > right.m_id;
          }
      }
  }
  */
};
struct comp
{
  bool operator()(song& left,song&  right)  //重载（）运算符
  {

      if(left.m_id == right.m_id)     //根据id去重
          return false;
      else
      {
          if(left.m_hot != right.m_hot)
          {
              return left.m_hot > right.m_hot;      //降序
          }
          else
          {
              return left.m_id > right.m_id;
          }

      }
  }

};
void main()
{
  std::set<song,comp> mySet;      //
  //std::set<song> mySet; //重载函数写在struct里面时
  song s1(10,100);
  song s2(20,200);
  song s3(20,300);
  song s4(30,200);
  mySet.insert(s1);    //插入s1
  mySet.insert(s2);    //插入s2
  mySet.insert(s3);    //s3和s2的id相同，不插入
  mySet.insert(s4);    //插入s4
  for(auto it:mySet)
  {
      std::cout<<"id:"<<it.m_id<<",hot:"<<it.m_hot<<std::endl;
  }
  std::cout<<"end"<<std::endl;
};

#include <map>

class MyCompare {
public:
 bool operator()(int v1, int v2) {
  return v1 > v2;
 }
};

int main() 
{
 //默认从小到大排序
 //利用仿函数实现从大到小排序
 map<int, int, MyCompare> m;

 m.insert(make_pair(1, 10));
 m.insert(make_pair(2, 20));
 m.insert(make_pair(3, 30));
 m.insert(make_pair(4, 40));
 m.insert(make_pair(5, 50));

 for (map<int, int, MyCompare>::iterator it = m.begin(); it != m.end(); it++) {
  cout << "key:" << it->first << " value:" << it->second << endl;
 }
    return 0;
}

// 类似于带`operator()`运算符重载的对象
UnaryFunc for_each( InputIt first, InputIt last, UnaryFunc f );
//普通函数、匿名函数
void for_each(ForwardIt first, ForwardIt last, UnaryFunc f );

// 对范围中所有元素返回 true 则为 true 。范围为空则返回 true。
bool all_of( InputIt first, InputIt last, UnaryPred p );

//对范围中至少有1个元素是true则返回true。
bool any_of( InputIt first, InputIt last,     UnaryPred p );

//对范围中都是false元素返回 true 。范围为空则返回true。
bool none_of( InputIt first, InputIt last, UnaryPred p );

//也支持ForwardIt
//搜索等于value的元素。
InputIt find( InputIt first, InputIt last, const T& value);

//搜索函数p返回true的元素。
InputIt find_if( InputIt first, InputIt last, UnaryPred p );

//搜索函数q返回false的元素。
InputIt find_if_not( InputIt first, InputIt last,UnaryPred q );

//在范围 [first, last) 中搜索范围 [s_first, s_last) 中的任何元素。
//用 operator== 比较元素。
InputIt find_first_of( InputIt first, InputIt last,ForwardIt s_first, ForwardIt s_last );

//用二元函数p比较
InputIt find_first_of( InputIt first, InputIt last,ForwardIt s_first, ForwardIt s_last, BinaryPred p );

//查找首先出现的位置
//用 operator== 比较元素。
ForwardIt1 search( ForwardIt1 first, ForwardIt1 last,ForwardIt2 s_first, ForwardIt2 s_last );

//用给定的二元谓词 p 比较。
ForwardIt1 search( ForwardIt1 first, ForwardIt1 last,ForwardIt2 s_first, ForwardIt2 s_last, BinaryPred p );

// 查找最后出现的位置
//用 operator== 比较元素。
ForwardIt1 find_end( ForwardIt1 first, ForwardIt1 last,ForwardIt2 s_first, ForwardIt2 s_last );

//用二元函数p比较元素。
ForwardIt1 find_end( ForwardIt1 first, ForwardIt1 last,ForwardIt2 s_first, ForwardIt2 s_last, BinaryPred p );

//在范围 [first, last) 中搜索二个相继的相等元素。
//用 operator== 比较元素。
ForwardIt adjacent_find( ForwardIt first, ForwardIt last );

//用给定的二元函数 p 比较元素。
ForwardIt adjacent_find( ForwardIt first, ForwardIt last, BinaryPred p );

//搜索n个连续相同的元素的子序列
ForwardIt search_n( ForwardIt first, ForwardIt last, Size count, const T& value );

ForwardIt search_n( ForwardIt first, ForwardIt last, Size count, const T& value, BinaryPred p );

//两个序列可以不等长
std::pair<InputIt1, InputIt2> mismatch( InputIt1 first1, InputIt1 last1, InputIt2 first2 );
std::pair<InputIt1, InputIt2> mismatch( InputIt1 first1, InputIt1 last1, InputIt2 first2, BinaryPred p );

bool equal( InputIt1 first1, InputIt1 last1, InputIt2 first2 );
bool equal( InputIt1 first1, InputIt1 last1, InputIt2 first2, BinaryPred p );

  
//复制范围中的元素到始于d_first的空间。
  
OutputIt copy( InputIt first, InputIt last, OutputIt d_first );
OutputIt copy_n( InputIt first, Size count, OutputIt result );
OutputIt copy_if( InputIt first, InputIt last, OutputIt d_first, UnaryPred pred );
  
// 逆序复制元素（首先复制末元素），但保持其相对顺序
BidirIt2 copy_backward(BidirIt1 first, BidirIt1 last, BidirIt2 d_last );
  
//移动
OutputIt move(InputIt first, InputIt last, OutputIt d_first );
BidirIt2 move_backward( BidirIt1 first, BidirIt1 last, BidirIt2 d_last );

void swap( T& a, T& b );
  
//交换 a 与 b 数组
void swap( T2 (&a)[N], T2 (&b)[N]);
  
// 在范围 [first1, last1) 和始于 first2 的另一范围间交换元素。
auto swap_ranges( I1 first1, S1 last1, I2 first2, S2 last2 );
  
//交换两个迭代器指向的元素
void iter_swap( ForwardIt1 a, ForwardIt2 b );

//给范围元素应用函数并存储结果于始于d_first的另一范围。
// 应用一元函数 unary_op。
OutputIt transform( InputIt first1, InputIt last1, OutputIt d_first,UnaryOperation unary_op );

//应用二元函数 binary_op 到来自二个范围的元素对：一个以 [first1, last1) 定义，而另一个始于 first2 。
OutputIt transform( InputIt1 first1, InputIt1 last1, InputIt2 first2, OutputIt d_first, BinaryOperation binary_op );

//以 new_value 替换范围中所有满足特定判别标准的元素。
//替换所有等于 old_value 的元素。
void replace( ForwardIt first, ForwardIt last, const T& old_value, const T& new_value );

//替换所有谓词 p 对其返回 true 的元素。
void replace_if( ForwardIt first, ForwardIt last, UnaryPred p, const T& new_value );

//复制范围的元素到始于 d_first 的范围，并以 new_value 替换所有满足特定判别标准的元素。
//替换所有等于 old_value 的元素。
OutputIt replace_copy( InputIt first, InputIt last, OutputIt d_first, const T& old_value, const T& new_value );

//替换所有函数 p 对其满足 true 的元素。
OutputIt replace_copy_if( InputIt first, InputIt last, OutputIt d_first,UnaryPred p, const T& new_value );

// 将给定值复制赋给一个范围中的每个元素
void fill(ForwardIt first, ForwardIt last, const T& value );
ForwardIt fill_n( ForwardIt first, Size count, const T& value )

//给定函数对象 g 所生成的值赋值范围中的每个元素。
//std::generate(v.begin(), v.end(), [n = 0] () mutable { return n++; });
template< class ForwardIt, class Generator >
void generate( ForwardIt first, ForwardIt last, Generator g );

OutputIt generate_n( OutputIt first, Size count, Generator g );

//移除所有满足条件的元素，并返回范围新结尾的尾后迭代器。
ForwardIt remove( ForwardIt first, ForwardIt last, const T& value );

ForwardIt remove_if( ForwardIt first, ForwardIt last, UnaryPred p );

//将范围元素复制到另外一个区间，并忽略满足条件的元素
OutputIt remove_copy( InputIt first, InputIt last,
                    OutputIt d_first, const T& value )
OutputIt remove_copy_if( InputIt first, InputIt last,
                       OutputIt d_first, UnaryPred p );

ForwardIt unique( ForwardIt first, ForwardIt last );

ForwardIt unique( ForwardIt first, ForwardIt last, BinaryPred p );


OutputIt unique_copy( InputIt first, InputIt last,
                  OutputIt d_first );

OutputIt unique_copy( InputIt first, InputIt last,
                  OutputIt d_first, BinaryPred p );

void reverse( BidirIt first, BidirIt last );

OutputIt reverse_copy( BidirIt first, BidirIt last, OutputIt d_first );

//进行元素范围上的左旋转。
ForwardIt rotate( ForwardIt first, ForwardIt n_first, ForwardIt last);

OutputIt rotate_copy( ForwardIt first, ForwardIt n_first,ForwardIt last, OutputIt d_first);

// 指定旋转n个位置
ForwardIt shift_left(ForwardIt first, ForwardIt last,
                     ifference_type n );
ForwardIt shift_right(ForwardIt first, ForwardIt last,
                     ifference_type n );

void random_shuffle(RandomIt first, RandomIt last);

//随机数生成器为函数对象 r
template< class RandomIt, class RandomFunc >
void random_shuffle( RandomIt first, RandomIt last, RandomFunc&& r );

// 随机数生成器为函数对象 g 
template< class RandomIt, class URBG >
void shuffle( RandomIt first, RandomIt last, URBG&& g );

template< class PopulationIt, class SampleIt, class Distance, class URBG >
SampleIterator sample( PopulationIt first, PopulationIt last, SampleIt out, Distance n, URBG&& g );

std::string in {"ABCDEFGHIJK"}, out;
std::sample(in.begin(), in.end(), std::back_inserter(out), 4,std::mt19937{std::random_device{}()});
std::cout << "Four random letters out of " << in << " : " << out << '\n';