备案控制台
探索云世界
开发者社区 开发与运维 文章 正文

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

2016-02-21 1842
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： <p></p> <h2><span style="font-family:宋体; font-size:16pt">boost_array_bind_fun_ref</span><span style="font-family:宋体; font-size:16pt"></span></h2> <p></p> <p>Array.cpp</p> <pre code_snippet_i

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


文章标签：
C++
Shell
Go
iOS开发
存储
关键词：
线程库
C++智能指针
C++指针
C++库
C++线程
吴英强
目录
相关文章
俄罗斯刺沙蓬
|
3天前
|
Linux API C++
c++多线程——互斥锁
c++多线程——互斥锁
俄罗斯刺沙蓬
13 0
wljslmz
|
8天前
|
并行计算 调度 C++
探索C++中的多线程编程：从基础到高级
【4月更文挑战第20天】
wljslmz
14 1
探索C++中的多线程编程：从基础到高级
1941623231718325
|
3天前
|
存储 算法 C++
详解C++中的STL（标准模板库）容器
【4月更文挑战第30天】C++ STL容器包括序列容器（如`vector`、`list`、`deque`、`forward_list`、`array`和`string`）、关联容器（如`set`、`multiset`、`map`和`multimap`）和容器适配器（如`stack`、`queue`和`priority_queue`）。它们为动态数组、链表、栈、队列、集合和映射等数据结构提供了高效实现。选择合适的容器类型可优化性能，满足不同编程需求。
1941623231718325
10 1
L&ecirc;v&iuml;
|
10天前
|
安全 Java 调度
C++从入门到精通：3.3多线程编程
C++从入门到精通：3.3多线程编程
L&ecirc;v&iuml;
21 0
L&ecirc;v&iuml;
|
10天前
|
存储 算法 程序员
C++从入门到精通：2.2.1标准库与STL容器算法深度解析
C++从入门到精通：2.2.1标准库与STL容器算法深度解析
L&ecirc;v&iuml;
20 0
同学小张
|
10天前
|
设计模式 安全 编译器
【代码片段】【C++】C++11线程安全单例模式
【代码片段】【C++】C++11线程安全单例模式
同学小张
14 1
下雪了-LKY
|
17天前
|
机器学习/深度学习 定位技术 C++
c++中常用库函数
c++中常用库函数
下雪了-LKY
38 0
小谢在努力
|
4天前
|
监控 安全 Java
【多线程学习】深入探究阻塞队列与生产者消费者模型和线程池常见面试题
【多线程学习】深入探究阻塞队列与生产者消费者模型和线程池常见面试题
小谢在努力
15 1
小谢在努力
|
4天前
|
缓存 安全 Java
多线程--深入探究多线程的重点,难点以及常考点线程安全问题
多线程--深入探究多线程的重点,难点以及常考点线程安全问题
小谢在努力
8 1
景天科技苑
|
5天前
|
数据采集 安全 Java
Python的多线程，守护线程，线程安全
Python的多线程，守护线程，线程安全
景天科技苑
14 2