C++课堂笔记

Sequential Containers

1.vector list 底层实现方式

push_back()操作

最差复杂度：线性

平均复杂度：常量

内存从8开始以指数增长

每增长到满一次拷贝内存一次

栗子：

shrink_to_tit()节省内存但消耗拷贝

如果拷贝到65535 但你要存70000个数据

但pushback就会翻倍增加空间，这时候要使用==shrink_to_tit();==

shrink_to_tit() 开辟刚好的内存

//用vector 实现栈

template <typename T>

class Stack

{

private:

vector <T> s;

public:

void push(T a)

{

s.push_back(a);

}

void pop()

{

s.pop_back();

}

unsigned long size()

{

return s.size();

}

T top()

{

if(s.size()>0){

//return s.back(); //ok

return s[s.size()-1];

}

}

};

2.Predicate(谓词)

栗子：

排序时候的cmp（）函数【自定义】

//二元谓词的使用

#include <vector>

using namespace std;

struct Node

{

double x,y;

};

bool cmp(const Node &a, const Node &b)

{

double ans1=a.x*a.x+a.y*a.y;

double ans2=b.x*b.x+b.y*b.y;

return ans1<ans2;//必须是严格的小于号

}

int main()

{

vector<Node> a;

Node n;

for(int i=0; i<3; i++)

{

cin>>n.x;

cin>>n.y;

a.push_back(n);

}

sort(a.begin(),a.end(),cmp);

for(int i=0; i<3; i++)

{

cout<<a[i].x<<a[i].y<<endl;

}

return 0;

}

3.replace_if()[一元谓词]

//写一个myreplace_if()

#include <iostream>

#include <algorithm>

using namespace std;

bool unaryPred(int n){

return n<0;

}

//这也是一种函数，用了运算符重载，--->在用类写的函数  函数就是一种类

class My_predicate{

public:

static bool operator()(int a){

return a<0;

}

};

/**

ForwardIt 只能向前走的迭代器，单向链表

为什么UnaryPredicate是class类型的？

一个函数也是个类

若不作为一个模板函数的话 可以这样写

栗子：bool(*P)(T)

是一次参数值为T返回值为bool的一个函数**/

template <typename T,class UnaryPredicate,class ForwardIt>

void my_replace_if(I first,I last,UnaryPredicate p,const T& new_value){

for (; first != last; ++first) {

if(p(*first)) {

*first = new_value;

}

}

}

int main()

{

int a[]={1,-1,2,-2,3,-3};

replace_if(a, a+6,unaryPred, 0);

for(int i=0;i<6;i++){

cout<<a[i];

}

return 0;

}

实现单向链表（用模板）