【C/C++学院】0904-boost智能指针/boost多线程锁定/哈希库/正則表達式

boost_array_bind_fun_ref

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();
}

boost智能指针

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();
}

boost多线程锁定

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();
}