使用python解方程组

机器视觉 - 图像读取

  返回  

stl 结束 模板进阶8.21

2021/8/21 18:00:55 浏览:

// 容器适配器 stl 8.21.cpp : 此文件包含 “main” 函数。程序执行将在此处开始并结束。
//

//#include
//
//int main()
//{
// std::cout << “Hello World!\n”;
//}
//
运行程序: Ctrl + F5 或调试 >“开始执行(不调试)”菜单
调试程序: F5 或调试 >“开始调试”菜单
//
入门使用技巧:
1. 使用解决方案资源管理器窗口添加/管理文件
2. 使用团队资源管理器窗口连接到源代码管理
3. 使用输出窗口查看生成输出和其他消息
4. 使用错误列表窗口查看错误
5. 转到“项目”>“添加新项”以创建新的代码文件,或转到“项目”>“添加现有项”以将现有代码文件添加到项目
6. 将来,若要再次打开此项目,请转到“文件”>“打开”>“项目”并选择 .sln 文件
//#include
//#include
//#include
//using namespace std;
//class Date
//{
//public:
// Date(int year = 1900, int month = 1, int day = 1)
// : _year(year)
// , _month(month)
// , _day(day)
// {}
// bool operator<(const Date& d)const
// {
// return (_year < d._year) ||
// (_year == d._year && _month < d._month) ||
// (_year == d._year && _month == d._month && _day < d._day);
// }
// bool operator>(const Date& d)const
// {
// return (_year > d._year) ||
// (_year == d._year && _month > d._month) ||
// (_year == d._year && _month == d._month && _day > d._day);
// }
// friend ostream& operator<<(ostream& _cout, const Date& d)
// {
// _cout << d._year << “-” << d._month << “-” << d._day;
// return _cout;
// }
//private:
// int _year;
// int _month;
// int _day;
//};
//void TestPriorityQueue()
//{
// // 大堆,需要用户在自定义类型中提供<的重载
// priority_queue q1;
// q1.push(Date(2018, 10, 29));
// q1.push(Date(2018, 10, 28));
// q1.push(Date(2018, 10, 30));
// cout << q1.top() << endl;
// // 如果要创建小堆,需要用户提供>的重载
// priority_queue<Date, vector, greater> q2;
// q2.push(Date(2018, 10, 29));
// q2.push(Date(2018, 10, 28));
// q2.push(Date(2018, 10, 30));
// cout << q2.top() << endl;
//}
//int main()
//{
// TestPriorityQueue();
// return 0;
//
//}

//优先级队列 就是这里是默认的大堆的存在,这是方便输出有序的数据,比如由大到小。或者由小到大。
//优先级队列的目的就是用来实现前多少个最值的操作。不用重新去建堆的操作。
//#include
//#include
//#include
//#include
//#include
//using namespace std;
自定义类型 可以存在,但是是必须要进行比较的操作。
//class A
//{
//public:
// A(int a = 1)
// :_a(a)
// {}
// bool operator<(const A& a) const
// {
// return _a < a._a;
// }
// //小堆的运算符重载
// bool operator>(const A& a) const
// {
// return _a > a._a;
// }
//private:
// int _a;
//};
自定义的演示
//void test1()
//{
// priority_queue pq;
// pq.push(A(1));
// pq.push(A(13));
// pq.push(A(15));
// pq.push(A(16));
// pq.push(A(11));
// while (!pq.empty())
// {
// cout << pq.top() << " ";
// //这里就是删除的操作。
// pq.top();
// }
// cout << endl;
//}
//void test()
//{
// //默认是大堆实现的
// //priority_queue pq;
// //这里是小堆的实现
// priority_queue<int,vector,greater> pq;
// pq.push(100);
// pq.push(100);
// pq.push(1);
// pq.push(124);
// pq.push(134);
// while (!pq.empty())
// {
// cout << pq.top() << " ";
// //这里就是删除的操作。
// pq.top();
// }
// cout << endl;
//}
//int main()
//{
// test();
// return 0;
//}

数组中第K个大的元素
//class solution
//{
//public:
// int findkthlargest(vector& nums, int k)
// {
// priority_queue pq;
// for (auto& e : nums)
// pq.push(e);
// while (k-- > 1)
// pq.pop();
// return pq.top();
// }
//};

//
//#include
//#include
//#include
//#include
//#include
//using namespace std;
优先级的实现
大堆的实现
//template
//class priorityQueue
//{
//public:
// //堆
// //向下调整
// void shiftDown()
// {
// int parent = 0;
// int child = 2 * parent + 1;
// while (child < arr.size())
// {
// if (child + 1 < arr.size() && arr[child] < arr[child + 1])
// child++;
// if (arr[parent] < arr[child])
// {
// swap(arr[parent], arr[child]);
// //更新
// parent = child;
// child = 2 * parent + 1;
// }
// else
// break;
// }
// }
// //向上调整
// void shiftUp(int child)
// {
// int parent = (child - 1) / 2;
// while (child > 0)
// {
// if (arr[parent]<arr[child])
// {
// swap(arr[parent], arr[child]);
// child = parent;
// parent = (child - 1) / 2;
// }
// else
// break;
// }
// }

使用仿函数来实现调整
//void shiftUp(int child)
// {
// int parent = (child - 1) / 2;
// while (child > 0)
// {
// //使用比较函数的调用来实现。
// if (cmp(arr[parent],arr[child]))
// {
// swap(arr[parent], arr[child]);
// child = parent;
// parent = (child - 1) / 2;
// }
// else
// break;
// }
// }

// void push(const T& val)
// {
// //尾插
// //arr[arr.size()] = val;//注意方括号的使用范围是0-size,不能等于size。否则是越界的。这里的操作是错误的。
// arr.push_back(val);
// //向上调整
// shiftUp(arr.size() - 1);
// }
// void pop()
// {
// //交换
// swap(arr[0], arr[arr.size() - 1]);
// //尾删
// arr.pop_back();
// //向下调整
// shiftDown();
// }
// T& top()
// {
// return arr.front;
// }
// size_t size()const
// {
// return arr.size();
// }
// bool empty()const
// {
// return arr.empty();
// }
//private:
// vector arr;
//};
//void test2()
//{
// //默认是大堆实现的
// //priority_queue pq;
// //这里是小堆的实现
// priority_queue<int, vector, greater> pq;
// pq.push(100);
// pq.push(100);
// pq.push(1);
// pq.push(124);
// pq.push(134);
// for (int i = 0; i < 1000; ++i)
// pq.push(i);
// while (!pq.empty())
// {
// cout << pq.top() << " ";
// //这里就是删除的操作。
// pq.top();
// }
// cout << endl;
//}
//
//int main()
//{
// test();
// return 0;
//}
//
//
//
//#include
//#include
//#include
//#include
//#include
//using namespace std;
库里边实现stack 默认是deque双端队列
vector 随机访问
// 实现的接口是下边的几个。
size,empty,back,front,push_back,pop_front
//
//template <class T,class container=deque>
//class stack
//{
// //size.empty,back,push_back,pop_back
//public:
// void push(const T& val)
// {
// _c.push_back(val);
// }
// void pop()
// {
// _c.pop_back();
// }
// T& top()
// {
// return _c.back();
// }
// size_t size() const
// {
// return _c.size();
// }
// bool empty() const
// {
// return _c.empty();
// }
//private:
// container _c;
//};
默认是双端队列
//void test()
//{
//
// //vector
// queue<int, vector> q;
// q.push(1);
// stack st;
// st.push(1);
// st.push(2);
// st.push(3);
// st.push(4);
// st.push(5);
// st.push(6);
// while (!st.empty())
// {
// cout << st.top() << " ";
// //这里就是删除的操作。
//
// }
// cout << endl;
//}
//int main()
//{
// test();
// return 0;
//}
//
//
熟悉各个容器的操作的接口
//void test()
//{
// stack st;
// st.push(1);
// st.push(2);
// st.push(3);
// st.push(4);
// st.push(5);
// st.push(6);
// while (!st.empty())
// {
// cout << st.top() << " ";
// //这里就是删除的操作。
// st.top();
// }
// cout << endl;
//}

size,empty,back,front,push_back,pop_front
//
//template <class T, class container = deque>
//class Queue
//{
//pubilc:
// void push(const T& val)
// {
// _c.push_back(val);
//
// }
// void pop()
// {
// _c.pop_front();
//
// }
// T& front()
// {
// return _c.front;
// }
// T& back()
// {
// return _c.back();
//
// }
// size_t size() const
// {
// return _c.size();
// }
// bool empty() const
// {
// return _c.empty();
// }
//};
//
这里是不能用list 因为list不支持随机访问。默认时候vector
//void test();
//{
// Queue q;
// q.push(0);
// q.push(1);
// q.push(2);
// q.push(3);
// queue<int, vector> q;
// //queue<int, deque> q;
// //queue q;
// while (!q.empty())
// {
// cout << q.top() << " ";
// //这里就是删除的操作。
// q.top();
// }
// cout << endl;
//}

//仿函数类:重载括号:“()”运算符
//通过仿函数来实现建堆的问题。
//template
//struct Greater
//{
// bool operator()(const T& a, const T& b)
// {
// return a > b;
//
// }
//
//};
//void test()
//{
// greater g;
// bool ret = g.operator()(10, 20);
// //简写形式 ret = g(10, 20);
//}
//
//template
//struct Less
//{
// bool operator()(const T& a, const T& b)
// {
// return a < b;
// }
//};
//void test()
//{
// Less g;
// bool ret = g.operator()(10, 20);
// //简写形式 ret = g(10, 20);
//}
//
仿函数增加程序的灵活性
仿函数的实现。
//
//
模板的高级版本
//template
//bool IsEqual(T& left, T& right)
//{
// return left == right;
//}
//
//void Test()
//{
// char* p1 = “hello”;
// char* p2 = “world”;
// if (IsEqual(p1, p2))
// cout << p1 << endl;
// else
// cout << p2 << endl;
//}
特化
//template<>
//bool IsEqual<char*>(char*& left, char*& right)
//{
// if (strcmp(left, right) > 0)
// return true;
//
// return false;
//}

联系我们

如果您对我们的服务有兴趣,请及时和我们联系!

服务热线:18288888888
座机:18288888888
传真:
邮箱:888888@qq.com
地址:郑州市文化路红专路93号