C++代碼測(cè)試壓力測(cè)試卷

```cpp

include<iostream>

include<vector>

include<list>

include<deque>

include<forward_list>

include<string>

include<algorithm>

include<set>

include<map>

include<unordered_set>

include<unordered_map>

include<stack>

include<queue>

include<functional>

include<thread>

include<mutex>

include<condition_variable>

include<future>

include<chrono>

include<random>

include<atomic>

include<memory>

//Functiontoperformstresstestonvectoroperations

voidstressTestVector(){

constsize_tTEST_SIZE=1000000;

std::vector<int>vec;

//Testpush_backandreserve

vec.reserve(TEST_SIZE);

for(size_ti=0;i<TEST_SIZE;++i){

vec.push_back(rand());

}

//Testclearandresize

vec.clear();

vec.resize(TEST_SIZE2);

//Testeraseandinsert

vec.erase(vec.begin(),vec.begin()+TEST_SIZE/2);

for(size_ti=0;i<TEST_SIZE/2;++i){

vec.insert(vec.begin(),rand());

}

//Testsortandreverse

std::sort(vec.begin(),vec.end());

std::reverse(vec.begin(),vec.end());

}

//Functiontoperformstresstestonlistoperations

voidstressTestList(){

constsize_tTEST_SIZE=1000000;

std::list<int>lst;

//Testpush_backandpush_front

for(size_ti=0;i<TEST_SIZE;++i){

lst.push_back(rand());

lst.push_front(rand());

}

//Testclearandresize

lst.clear();

lst.resize(TEST_SIZE);

//Testremoveandremove_if

for(size_ti=0;i<TEST_SIZE;++i){

lst.remove(rand());

}

lst.remove_if([](intx){returnx%2==0;});

//Testsortandreverse

lst.sort();

lst.reverse();

}

//Functiontoperformstresstestondequeoperations

voidstressTestDeque(){

constsize_tTEST_SIZE=1000000;

std::deque<int>dq;

//Testpush_backandpush_front

for(size_ti=0;i<TEST_SIZE;++i){

dq.push_back(rand());

dq.push_front(rand());

}

//Testclearandresize

dq.clear();

dq.resize(TEST_SIZE);

//Testeraseandinsert

dq.erase(dq.begin(),dq.begin()+TEST_SIZE/2);

for(size_ti=0;i<TEST_SIZE/2;++i){

dq.insert(dq.begin(),rand());

}

//Testsortandreverse

std::sort(dq.begin(),dq.end());

std::reverse(dq.begin(),dq.end());

}

//Functiontoperformstresstestonforward_listoperations

voidstressTestForwardList(){

constsize_tTEST_SIZE=1000000;

std::forward_list<int>flst;

//Testpush_front

for(size_ti=0;i<TEST_SIZE;++i){

flst.push_front(rand());

}

//Testclearandresize

flst.clear();

flst.resize(TEST_SIZE);

//Testremoveandremove_if

for(size_ti=0;i<TEST_SIZE;++i){

flst.remove(rand());

}

flst.remove_if([](intx){returnx%2==0;});

}

//Functiontoperformstresstestonstringoperations

voidstressTestString(){

constsize_tTEST_SIZE=1000000;

std::stringstr;

//Testappend

for(size_ti=0;i<TEST_SIZE;++i){

str.append(std::to_string(rand()));

}

//Testclearandresize

str.clear();

str.resize(TEST_SIZE);

//Testeraseandinsert

str.erase(str.begin(),str.begin()+TEST_SIZE/2);

for(size_ti=0;i<TEST_SIZE/2;++i){

str.insert(str.begin(),std::to_string(rand()));

}

//Testsortandreverse

std::sort(str.begin(),str.end());

std::reverse(str.begin(),str.end());

}

//Functiontoperformstresstestonsetoperations

voidstressTestSet(){

constsize_tTEST_SIZE=1000000;

std::set<int>st;

//Testinsert

for(size_ti=0;i<TEST_SIZE;++i){

st.insert(rand());

}

//Testclearandresize

st.clear();

st.resize(TEST_SIZE);

//Testeraseandfind

for(size_ti=0;i<TEST_SIZE;++i){

st.erase(rand());

}

for(size_ti=0;i<TEST_SIZE;++i){

st.find(rand());

}

}

//Functiontoperformstresstestonmapoperations

voidstressTestMap(){

constsize_tTEST_SIZE=1000000;

std::map<int,int>mp;

//Testinsert

for(size_ti=0;i<TEST_SIZE;++i){

mp.insert(std::make_pair(rand(),rand()));

}

//Testclearandresize

mp.clear();

mp.resize(TEST_SIZE);

//Testeraseandfind

for(size_ti=0;i<TEST_SIZE;++i){

mp.erase(rand());

}

for(size_ti=0;i<TEST_SIZE;++i){

mp.find(rand());

}

}

//Functiontoperformstresstestonunordered_setoperations

voidstressTestUnorderedSet(){

constsize_tTEST_SIZE=1000000;

std::unordered_set<int>ust;

//Testinsert

for(size_ti=0;i<TEST_SIZE;++i){

ust.insert(rand());

}

//Testclearandresize

ust.clear();

ust.resize(TEST_SIZE);

//Testeraseandfind

for(size_ti=0;i<TEST_SIZE;++i){

ust.erase(rand());

}

for(size_ti=0;i<TEST_SIZE;++i){

ust.find(rand());

}

}

//Functiontoperformstresstestonunordered_mapoperations

voidstressTestUnorderedMap(){

constsize_tTEST_SIZE=1000000;

std::unordered_map<int,int>ump;

//Testinsert

for(size_ti=0;i<TEST_SIZE;++i){

ump.insert(std::make_pair(rand(),rand()));

}

//Testclearandresize

ump.clear();

ump.resize(TEST_SIZE);

//Testeraseandfind

for(size_ti=0;i<TEST_SIZE;++i){

ump.erase(rand());

}

for(size_ti=0;i<TEST_SIZE;++i){

ump.find(rand());

}

}

//Functiontoperformstresstestonstackoperations

voidstressTestStack(){

constsize_tTEST_SIZE=1000000;

std::stack<int>stk;

//Testpushandpop

for(size_ti=0;i<TEST_SIZE;++i){

stk.push(rand());

}

for(size_ti=0;i<TEST_SIZE;++i){

stk.pop();

}

}

//Functiontoperformstresstestonqueueoperations

voidstressTestQueue(){

constsize_tTEST_SIZE=1000000;

std::queue<int>q;

//Testpushandpop

for(size_ti=0;i<TEST_SIZE;++i){

q.push(rand());

}

for(size_ti=0;i<TEST_SIZE;++i){

q.pop();

}

}

//Functiontoperformstresstestonpriority_queueoperations

voidstressTestPriorityQueue(){

constsize_tTEST_SIZE=1000000;

std::priority_queue<int>pq;

//Testpushandpop

for(size_ti=0;i<TEST_SIZE;++i){

pq.push(rand());

}

for(size_ti=0;i<TEST_SIZE;++i){

pq.pop();

}

}

//Functiontoperformstresstestonfunctionobjects

voidstressTestFunctionObjects(){

constsize_tTEST_SIZE=1000000;

std::function<void()>func=[](){

std::this_thread::sleep_for(std::chrono::milliseconds(1));

};

for(size_ti=0;i<TEST_SIZE;++i){

func();

}

}

//Functiontoperformstresstestonthreadsandmutexes

voidstressTestThreadsAndMutexes(){

constsize_tNUM_THREADS=10;

std::mutexmtx;

std::atomic<int>counter(0);

std::vector<std::thread>threads;

for(size_ti=0;i<NUM_THREADS;++i){

threads.emplace_back([&](){

for(size_tj=0;j<100000;++j){

mtx.lock();

++counter;

mtx.unlock();

}

});

}

for(auto&th:threads){

th.join();

}

std::cout<<"Countervalue:"<<counter<<std::endl;

}

//Functiontoperformstresstestonconditionvariables

voidstressTestConditionVariables(){

std::mutexmtx;

std::condition_variablecv;

boolready=false;

std::threadproducer([&](){

std::unique_lock<std::mutex>lock(mtx);

ready=true;

cv.notify_one();

});

std::threadconsumer([&](){

std::unique_lock<std::mutex>lock(mtx);

cv.wait(lock,[&]{returnready;});

std::cout<<"Conditionvariabletestpassed"<<std::endl;

});

producer.join();

consumer.join();

}

//Functiontoperformstresstestonfutures

voidstressTestFutures(){

constsize_tNUM_FUTURES=1000;

std::vector<std::future<void>>futures;

for(size_ti=0;i<NUM_FUTURES;++i){

futures.emplace_back(std::async(std::launch::async,[](){

std::this_thread::sleep_for(std::chrono::milliseconds(1));

}));

}

for(auto&fut:futures){

fut.get();

}

}

//Functiontoperformstresstestonatomics

voidstressTestAtomics(){

constsize_tNUM_THREADS=10;

std::vector<std::thread>threads;

std::atomic<int>counter(0);

for(size_ti=0;i<NUM_THREADS;++i){

threads.emplace_back([&](){

for(size_tj=0;j<100000;++j){

++counter;

}

});

}

for(auto&th:threads){

th.join();

}

std::cout<<"Atomiccountervalue:"<<counter<<std::endl;

}

/