AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

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

2016-02-21 1906
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： <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++线程
C++ boost
吴英强
目录
相关文章
Svan.
|
3月前
|
算法 C++ 容器
C++标准库（速查）总结
C++标准库（速查）总结
Svan.
96 6
技术小达人
|
4天前
|
JSON C++ 数据格式
C++20 高性能基础库--兰亭集库助力开发者构建高性能应用
这次分享的主题是《高性能基础库--兰亭集库助力开发者构建高性能应用》的实践经验。主要分为三个部分： 1. 业务背景 2. 雅兰亭库架构 3. 业务优化
技术小达人
24 9
蓝易云
|
16天前
|
XML 网络协议 API
超级好用的C++实用库之服务包装类
通过本文对Boost.Asio、gRPC和Poco三个超级好用的C++服务包装类库的详细介绍，开发者可以根据自己的需求选择合适的库来简化开发工作，提高代码的效率和可维护性。每个库都有其独特的优势和适用场景，合理使用这些库可以极大地提升C++开发的生产力。
蓝易云
36 11
潇洒洒
|
2月前
|
消息中间件 存储 安全
深入探索C++无锁队列：多线程编程的高效利器
【10月更文挑战第19天】
潇洒洒
222 6
小王老师呀
|
3月前
|
存储 并行计算 安全
C++多线程应用
【10月更文挑战第29天】C++ 中的多线程应用广泛，常见场景包括并行计算、网络编程中的并发服务器和图形用户界面（GUI）应用。通过多线程可以显著提升计算速度和响应能力。示例代码展示了如何使用 `pthread` 库创建和管理线程。注意事项包括数据同步与互斥、线程间通信和线程安全的类设计，以确保程序的正确性和稳定性。
小王老师呀
73 5
Svan.
|
3月前
|
存储 程序员 C++
C++常用基础知识—STL库(2)
C++常用基础知识—STL库(2)
Svan.
96 5
RossyYan
|
11天前
|
C++ 芯片
【C++面向对象——类与对象】Computer类（头歌实践教学平台习题）【合集】
声明一个简单的Computer类，含有数据成员芯片（cpu）、内存（ram）、光驱（cdrom）等等，以及两个公有成员函数run、stop。只能在类的内部访问。这是一种数据隐藏的机制，用于保护类的数据不被外部随意修改。根据提示，在右侧编辑器补充代码，平台会对你编写的代码进行测试。成员可以在派生类（继承该类的子类）中访问。成员，在类的外部不能直接访问。可以在类的外部直接访问。为了完成本关任务，你需要掌握。
RossyYan
51 18
RossyYan
|
11天前
|
存储 编译器 数据安全/隐私保护
【C++面向对象——类与对象】CPU类（头歌实践教学平台习题）【合集】
声明一个CPU类，包含等级（rank）、频率（frequency）、电压（voltage）等属性，以及两个公有成员函数run、stop。根据提示，在右侧编辑器补充代码，平台会对你编写的代码进行测试。​ 相关知识 类的声明和使用。 类的声明和对象的声明。 构造函数和析构函数的执行。 一、类的声明和使用 1.类的声明基础 在C++中，类是创建对象的蓝图。类的声明定义了类的成员，包括数据成员（变量）和成员函数（方法）。一个简单的类声明示例如下： classMyClass{ public: int
RossyYan
37 13
RossyYan
|
11天前
|
编译器 数据安全/隐私保护 C++
【C++面向对象——继承与派生】派生类的应用（头歌实践教学平台习题）【合集】
本实验旨在学习类的继承关系、不同继承方式下的访问控制及利用虚基类解决二义性问题。主要内容包括： 1. **类的继承关系基础概念**：介绍继承的定义及声明派生类的语法。 2. **不同继承方式下对基类成员的访问控制**：详细说明`public`、`private`和`protected`继承方式对基类成员的访问权限影响。 3. **利用虚基类解决二义性问题**：解释多继承中可能出现的二义性及其解决方案——虚基类。 实验任务要求从`people`类派生出`student`、`teacher`、`graduate`和`TA`类，添加特定属性并测试这些类的功能。最终通过创建教师和助教实例，验证代码
RossyYan
37 5
RossyYan
|
11天前
|
存储 算法 搜索推荐
【C++面向对象——群体类和群体数据的组织】实现含排序功能的数组类（头歌实践教学平台习题）【合集】
1. **相关排序和查找算法的原理**：介绍直接插入排序、直接选择排序、冒泡排序和顺序查找的基本原理及其实现代码。 2. **C++ 类与成员函数的定义**：讲解如何定义`Array`类，包括类的声明和实现，以及成员函数的定义与调用。 3. **数组作为类的成员变量的处理**：探讨内存管理和正确访问数组元素的方法，确保在类中正确使用动态分配的数组。 4. **函数参数传递与返回值处理**：解释排序和查找函数的参数传递方式及返回值处理，确保函数功能正确实现。 通过掌握这些知识，可以顺利地将排序和查找算法封装到`Array`类中，并进行测试验证。编程要求是在右侧编辑器补充代码以实现三种排序算法
RossyYan
27 5