c/c++语言开发共享浅谈C++标准库

目录

• c++模板
• c++标准库
• c++ 面向对象类库

  //函数模板  template <typename type> ret-type func-name(parameter list)  {     // 函数的主体  }    //类模板  template <class type> class class-name {  .  .  }  

  string s1; //初始化字符串，空字符串，可变长  string s2 = "i am wenny"; //直接初始化  string s3 = string(6,'c'); //拷贝初始化  //cin>>s1;  //遇到空白停止读取  cout<<s2;  str.c_str(); //将string型str使用c_str()变为字符数组，可以使用printf进行输出  cout<<s2[0];  //可以使用下标引用  s2=s1;  //用s1代替s2  s1=s1+s2;  //连接s1和s2    getline(cin,s3); //获取有空白符的一整行内容，按回车键结束输入,不能输入字符数组；输入遗留在输入缓冲的换行符消除  getline(cin,s3,'#')  //输入一串字符（无论多少个回车键），只要是在‘#'之前的字符都会读取并保存  s3.erase(10,8);  //删除s3[10]开始的8个字符，时间复杂度o(n)  s3.insert(2,"bbb"); //在s3中下标为2的字符前插入字符串，时间复杂度o(n)  s3.insert(it,it2,it3);  //迭代器，表示串[it2,it3)将被插入在it的位置    cout<<s2.find("am",0);  //返回子串位置，第二个参数是查找起始位置,如果没有找到返回string::npos；时间复杂度o(nm),n和m分别为str和str2的长度  s2.empty();  s2.size();  s2.substr(pos,len); //从pos号位开始，长度为len的子串，时间复杂度o(len)  s2.replace(pos,len,str2);  //从pos号为开始、长度为len的子串替换为str2；时间复杂度o(str.length())  

  template <typename t>  inline void showset(set<t> v){      for(typename set<t>::iterator it=v.begin();it!=v.end();it++)          cout<<*it<<" ";      cout<<endl;  }  

  //初始化  vector<int> v1;  vector<vector<int>> v2;  //相当于变长二维数组  vector<int> v[100]; //相当于二维数组，第一维已经固定长度  vector<int> v3={1,2,3,4};  vector<string> v4(3,"hi");  vector<int> v5(4);  //默认初始化为0，字符串默认为空  //操作  v1.push_back(2); //向末尾添加对对象，时间复杂度o(1)  v1.pop_back(); //删除尾部的对象，时间复杂度o(1)  v1.empty(); //返回bool值  v3.size();  //返回vector种元素的个数，时间复杂度o(1)  v1.clear(); //删除所有元素，时间复杂度o(n)  v1.insert(v1.begin(),3); //插入一个或多个元素，时间复杂度o(n)  v1.erase(v1.begin());  //删除一个或多个元素，时间复杂度o(n)  v1=v3;  //使用了迭代器的循环体，不要向迭代器所属容器添加元素  cout<<v1[0]; //返回v种第0个位置上元素的引用  cout<<(v1==v5);  //相等当且仅当元素数量相同且对应位置的元素值都相同  

  set<int> s1={9,8,7,6,5,4};  //从小到大自动排序  showset(s1);  //cout<<s1[1]; //不能使用下标引用    set<string> s2={"hello","world","apple"};  //字典序排序  showset(s2);        s1.insert(9);  //已存在没有插入动作，时间复杂度o(logn)  showset(s1);  s2.insert("banana"); //添加并排序  showset(s2);    set<int>::iterator it s1.find(2); //返回value对应的迭代器，时间复杂度o(logn)  s1.erase(); //参数是迭代器，时间复杂度为o(1);参数是value，时间复杂度是o(logn)  

  list<int> l1={6,7,3,4};  showlist(l1);  list<char> l2(5,'a');  showlist(l2);    l1.sort(); //list自己的排序函数，无参数  showlist(l1);  

  void showmap(map<string,int> v){      for(map<string,int>::iterator it=v.begin();it!=v.end();it++)          cout<<it->first<<" "<<it->second<<endl;  //first表示key，second表示value      cout<<endl;  }    int main()  {      map<string,int> m1;  //第一个参数是key，第二个参数是value      m1["jojo"]=100;      m1["kiki"]=99; //会以键从小到大的顺序自动排序        cout<<m1["jojo"]<<endl;        cout<<m1.count("wenny"); //判断是否存在key，返回1或0      cout<<m1["test"]<<endl; //不存在key，则显示0，但会插入到map中            showmap(m1);      m1.erase("kiki");  //通过关键字删除元素,时间复杂度o(logn)；直接删除迭代器时间复杂度o(1)      showmap(m1);      m1.insert(pair<string,int>("harr",89));  //增加元素      showmap(m1);      m1.clear();  //清空元素      m1.find(b);  //确定map中是否有string对象b的映射，若没有函数返回m1.end()；时间复杂度o(logn)      return 0;    }  

  queue<int> q1;  q1.front(); //因为是限制性数据结构，只能通过front()来访问队首元素，back()来访问队尾元素  q1.back();  q1.push(1);  q1.pop();  q1.empty();  q1.size();  

  priority_queue<int,vector<int>,greater<int>> q;  //从大到小排序，数字越小优先级越大  priority_queue<int,vector<int>,less<int>> q2;  //从小到大排序，数字越大优先级越大；默认  q.push(3);  //入队，时间复杂度o(logn)  q.push(2);    q.push(4);  cout<<q.top();  //获得队首元素，即堆顶元素  q.pop();  //出队，时间复杂度o(logn)  cout<<q.top();  cout<<q.empty();  struct fru{  	string name;  	int price;  	bool operator < (const fru &b) const{  		return price>b.price;  	}  };  priority_queue<fru> q3; //按照重载的运算符<排序  fru f1,f2,f3;  f1.name = "peach";  f1.price = 3;  f2.name = "apple";  f2.price = 1;  q3.push(f1);  q3.push(f2);  cout<<endl<<q3.top().name<<" "<<q3.top().price;  struct cmp{  	bool operator () (const fru &a,const fru &b){  		return a.price>b.price;  	}  };  priority_queue<fru,vector<fru>,cmp> q4; //重写排序规则  q4.push(f1);  q4.push(f2);  cout<<endl<<q4.top().name<<" "<<q4.top().price;  

  stack<int> s;  s.push(1);  //入栈，时间复杂度o(1)  s.push(2);  s.push(3);  s.pop();  //出栈，时间复杂度o(1)  cout<<s.top()<<endl;  //获得栈顶元素，时间复杂度o(1)  cout<<s.empty()<<endl;  cout<<s.size()<<endl;  

  struct pair{  	typename first;  	typename second;  };  pair<string,int> p;  p.first = "haha";  p.second = 5;  p = make_pair("xixi",55);  //临时构建一个pair  p = pair<string,int>("heihei",555);  //临时构建一个pair  cout<<(p1>=p2);  //可以直接使用比较操作数  

  int x=-1,y=2;  double a=0.1,b=0.2;  max(x,y);  //参数只能是两个  min(a,b);  abs(x);  //x必须是整数  swap(x,y);  //交换x和y的值  int c[3]={1,2,3};  reverse(c,c+3);  //将数组指针在[it，it2）之间的元素或容器的迭代器在[it，it2）范围内的元素进行反转  int d[10]={1,2,3};  do{      cout<<a[0]<<a[1]<<a[2]<<endl;  }while(next_permutation(d,d+3));  //函数给出一个序列在全排列中的下一个序列，到达全排列最后一个时会返回false  fill(d,d+2,5);  //把数组或容器的[it，it2)赋为某个相同的值  sort(d,d+3);  //默认递增排序  //用在有序数组或容器中；时间复杂度o(log(last-first))；返回位置的指针或迭代器  lower_bound(d,d+3,2);  //寻找第一个大于等于val的元素位置  upper_bound(d,d+3,2);  //寻找第一个大于val的元素位置