标签：[1] out match cin infinite return 智能指针 rtp 内存
Array.cpp
#include<boost/array.hpp>
#include <iostream>
#include <string>
using namespace std;
using namespace boost;
void mainA ()
{
array <int, 5> barray = { 1, 2, 3, 4, 5 };
barray[0] = 10;
barray.at(4) = 20;
int *p = barray.data();//存储数组的指针
for (int i = 0; i < barray.size();i++)
{
cout << barray[i] << " " << p[i] << endl;
}
array<string, 3> cmd = { "calc", "notepad", "tasklist" };
cin.get();
}
Bind.cpp
#include <iostream>
#include <string>
#include <boost/bind.hpp>
#include <vector>
#include <algorithm>
#include <functional>
using namespace std;
using namespace boost;
//绑定函数的默认值，继承二进制函数类的全部类容
class add:public std::binary_function<int ,int,void>
{
public:
void operator()(int i,int j) const
{
std::cout << i + j << endl;
}
};
void add(int i, int j)
{
std::cout << i + j << endl;
}
void mainB()
{
vector<int> myv;
myv.push_back(11);
myv.push_back(23);
myv.push_back(34);
//for_each(myv.begin(), myv.end(), bind1st(add(),10));
for_each(myv.begin(), myv.end(), bind(add, 13, _1));
//bind设置默认參数调用，函数副本机制。不能拷贝构造
cin.get();
}
Fun.cpp
#include <iostream>
#include <string>
#include <boost/bind.hpp>
#include <boost/function.hpp>
#include <vector>
#include <algorithm>
#include <functional>
#include <stdlib.h>
using namespace std;
using namespace boost;
void mainC()
{
//atoi //char * to int
boost::function<int(char *)> fun = atoi;
cout << fun("123") + fun("234") << endl;
fun = strlen;
cout << fun("123") + fun("234") << endl;
cin.get();
}
void mainD()
{
boost::function<int(char *)> fun = atoi;
cout << fun("123") + fun("234") << endl;
fun = boost::bind(strcmp, "ABC", _1);
cout << fun("123") << endl;
cout << fun("ABC") << endl;
cin.get();
}
class manager
{
public:
void allstart()
{
for (int i = 0; i < 10;i++)
{
if (workid)
{
workid(i);
}
}
}
void setcallback(boost::function<void(int)> newid)//绑定调用
{
workid = newid;
}
public:
boost::function<void(int)> workid;
};
class worker
{
public:
void run(int toid)
{
id = toid;
cout << id << "工作" << endl;
}
public:
int id;
};
void mainE()
{
manager m;
worker w;
//类的成员函数须要对象来调用，绑定了一个默认的对象
m.setcallback(boost::bind(&worker::run, &w, _1));
m.allstart();
cin.get();
}
Ref.cpp
#include <iostream>
#include <string>
#include <boost/bind.hpp>
#include <boost/function.hpp>
#include <vector>
#include <algorithm>
#include <functional>
#include <stdlib.h>
using namespace std;
using namespace boost;
void print(std::ostream &os,int i)
{
os << i << endl;
}
void mainF()
{
//不能够拷贝的对象能够用ref
boost::function<void(int)> pt = boost::bind(print,boost::ref(cout), _1);
vector<int > v;
v.push_back(11);
v.push_back(12);
v.push_back(13);
for_each(v.begin(), v.end(), pt);
std::cin.get();
}
RAII原理.cpp
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <stdlib.h>
#include <string>
using namespace std;
class mystr
{
public:
char *p = nullptr;
public:
mystr(const char *str)
{
cout << "构建" << endl;
int length = strlen(str);
p = new char[length + 1];
strcpy(p, str);
p[length] = '\0';
}
~mystr()
{
cout << "销毁" << endl;
delete[] p;
}
};
void go()
{
char *p = new char[100];
mystr str1 = "ABCD";//RAII避免内存泄漏，普通情况下，堆上的内存当作栈上来使用
//栈内存有限。希望自己主动释放，用非常大的内存。
}
void mainHG()
{
go();
cin.get();
}
Smartpointer原理.cpp
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <functional>
#include <stdlib.h>
using namespace std;
template<class T>
class pmy
{
public:
pmy()
{
}
pmy(T *t)
{
p = t;
}
~pmy()
{
if (p!=nullptr)
{
delete p;
}
}
T operator *()
{
return *p;
}
private:
T *p=nullptr;
};
class Test
{
public:
Test()
{
cout << "Test create" << endl;
}
~Test()
{
cout << "Test delete" << endl;
}
};
void run()
{
pmy<Test> p(new Test);//智能指针，智能释放
//*p;
}
void mainH()
{
run();
cin.get();
}
Smartpointer.cpp
#include <iostream>
#include <vector>
#include<algorithm>
#include <boost/scoped_ptr.hpp>
#include <boost/scoped_array.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/shared_array.hpp>
#include<boost/weak_ptr.hpp>
#include <windows.h>
using namespace std;
void mainI()
{
boost::scoped_ptr<int> p(new int);//自己主动释放内存
*p = 12;
cout << *p.get() << endl;
p.reset(new int);
*p.get() = 3;
boost::scoped_ptr<int> pA(nullptr);//独占内存
//pA = p;
cout << *p.get() << endl;
cin.get();
}
void mainG()
{
boost::scoped_array<int> p(new int[10]);//自己主动释放内存
//boost::scoped_array<int> pA(p);独享指针
*p.get() = 1;
p[3] = 2;
p.reset(new int[5]);//仅仅能指针
cin.get();
}
void show(boost::shared_ptr<int> p)
{
cout << *p << endl;
}
void mainK()
{
vector<boost::shared_ptr<int> > v;
boost::shared_ptr<int> p1(new int(11));
boost::shared_ptr<int> p2(new int(12));
boost::shared_ptr<int> p3(p2);//拷贝
v.push_back(p1);
v.push_back(p2);
v.push_back(p3);
for_each(v.begin(), v.end(), show);
cin.get();
}
class runclass
{
public:
int i = 0;
public:
runclass(int num) :i(num)
{
cout << "i create" <<i<< endl;
}
runclass()
{
cout << "i create" << i << endl;
}
~runclass()
{
cout << "i delete" <<i<< endl;
}
void print()
{
cout << "i =" << i<<endl;
}
};
void testfun()
{
boost::shared_ptr<runclass> p1(new runclass(10));
boost::shared_ptr<runclass> p2(p1);
boost::shared_ptr<runclass> p3(p1);
p1.reset(new runclass(12));
p1->print();
p2->print();
p3->print();
}
void testfunarray()
{
boost::shared_array<runclass> p1(new runclass[5]);
boost::shared_array<runclass> p2(p1);
}
void mainL()
{
//testfun();
testfunarray();
cin.get();
}
DWORD WINAPI reset(LPVOID p)
{
boost::shared_ptr<int > *sh = static_cast<boost::shared_ptr<int > *> (p);
sh->reset();//指针的重置,释放内存
std::cout << "指针运行释放" << endl;
return 0;
}
DWORD WINAPI print(LPVOID p)
{
boost::weak_ptr<int > * pw = static_cast<boost::weak_ptr<int > *>(p);
boost::shared_ptr<int > sh = pw->lock();//锁定不能够释放
Sleep(5000);
if (sh)
{
std::cout << *sh << endl;
}
else
{
std::cout << "指针已经被释放" << endl;
}
return 0;
}
void main123()
{
boost::shared_ptr<int> sh(new int(99));
boost::weak_ptr<int > pw(sh);
HANDLE threads[2];
threads[0] = CreateThread(0, 0, reset, &sh, 0, 0);//创建一个线程
threads[1] = CreateThread(0, 0, print, &pw, 0, 0);
Sleep(1000);
WaitForMultipleObjects(2, threads, TRUE, INFINITE);//等待线程结束
cin.get();
}
Thread.cpp
#include <iostream>
#include <vector>
#include<algorithm>
#include<boost/thread.hpp>
#include <windows.h>
using namespace std;
using namespace boost;
void wait(int sec)
{
boost::this_thread::sleep(boost::posix_time::seconds(sec));
}
void threadA()
{
for (int i = 0; i < 10;i++)
{
wait(1);
std::cout << i << endl;
}
}
void threadB()
{
try
{
for (int i = 0; i < 10; i++)
{
wait(1);
std::cout << i << endl;
}
}
catch (boost::thread_interrupted &)
{
}
}
void mainO()
{
boost::thread t(threadA );
wait(3);
//t.interrupt();
t.join();
cin.get();
}
Unorderred.cpp
#include <iostream>
#include<boost/unordered_set.hpp>
#include<string>
using namespace std;
void mainAAAC()
{
boost::unordered_set<std::string> myhashset;
myhashset.insert("ABC");
myhashset.insert("ABCA");
myhashset.insert("ABCAG");
for (auto ib = myhashset.begin(); ib != myhashset.end();ib++)
{
cout << *ib << endl;
}
std::cout << (myhashset.find("ABCA1") != myhashset.end()) << endl;
cin.get();
}
Regex.cpp
#include <boost/regex.hpp>
#include <locale>
#include <iostream>
#include <string>
using namespace std;
void mainA123()
{
std::locale::global(std::locale("English"));
string str = "chinaen8Glish";
boost::regex expr("\\w+\\d\\u\\w+");//d代表数字，
//匹配就是1，不匹配就是0
cout << boost::regex_match(str, expr) << endl;
cin.get();
}
void mainB123()
{
//std::locale::global(std::locale("English"));
string str = "chinaen8Glish9abv";
boost::regex expr("(\\w+)\\d(\\w+)");//d代表数字，
boost::smatch what;
if (boost::regex_search(str,what,expr))//依照表达式检索
{
cout << what[0] << endl;
cout << what[1] << endl;
}
else
{
cout << "检索失败";
}
cin.get();
}
void mainC1234()
{
string str = "chinaen8 Glish9abv";
boost::regex expr("\\d");//d代表数字，
string kongge = "______";
std::cout << boost::regex_replace(str, expr, kongge) << endl;
cin.get();
}
【C/C++学院】0904-boost智能指针/boost多线程锁定/哈希库/正則表達式
标签：[1] out match cin infinite return 智能指针 rtp 内存
原文地址：http://www.cnblogs.com/tlnshuju/p/7390639.html
