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

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


目录
打赏
0
0
0
0
13
分享
相关文章
深入解析C++中的函数指针与`typedef`的妙用
本文深入解析了C++中的函数指针及其与`typedef`的结合使用。通过图示和代码示例,详细介绍了函数指针的基本概念、声明和使用方法,并展示了如何利用`typedef`简化复杂的函数指针声明,提升代码的可读性和可维护性。
83 0
【c++】类和对象(上)(类的定义格式、访问限定符、类域、类的实例化、对象的内存大小、this指针)
本文介绍了C++中的类和对象,包括类的概念、定义格式、访问限定符、类域、对象的创建及内存大小、以及this指针。通过示例代码详细解释了类的定义、成员函数和成员变量的作用,以及如何使用访问限定符控制成员的访问权限。此外,还讨论了对象的内存分配规则和this指针的使用场景,帮助读者深入理解面向对象编程的核心概念。
199 4
|
2月前
|
C++无锁队列:解锁多线程编程新境界
【10月更文挑战第27天】
123 7
C++ 多线程之初识多线程
这篇文章介绍了C++多线程的基本概念,包括进程和线程的定义、并发的实现方式,以及如何在C++中创建和管理线程,包括使用`std::thread`库、线程的join和detach方法,并通过示例代码展示了如何创建和使用多线程。
72 1
C++多线程应用
【10月更文挑战第29天】C++ 中的多线程应用广泛,常见场景包括并行计算、网络编程中的并发服务器和图形用户界面(GUI)应用。通过多线程可以显著提升计算速度和响应能力。示例代码展示了如何使用 `pthread` 库创建和管理线程。注意事项包括数据同步与互斥、线程间通信和线程安全的类设计,以确保程序的正确性和稳定性。
在 C++中,引用和指针的区别
在C++中,引用和指针都是用于间接访问对象的工具,但它们有显著区别。引用是对象的别名,必须在定义时初始化且不可重新绑定;指针是一个变量,可以指向不同对象,也可为空。引用更安全,指针更灵活。
多线程;顺序容器;智能指针
【10月更文挑战第14天】多线程的创建创建线程比较简单,C++提供头文件thread,使用std的thread实例化一个线程对象创建。 std::thread 在 #include 头文件中声明,因此使用 std::thread 时需要包含 #include 头文件。
C++ 多线程之带返回值的线程处理函数
这篇文章介绍了在C++中使用`async`函数、`packaged_task`和`promise`三种方法来创建带返回值的线程处理函数。
127 6
c++写高性能的任务流线程池(万字详解!)
本文介绍了一种高性能的任务流线程池设计,涵盖多种优化机制。首先介绍了Work Steal机制,通过任务偷窃提高资源利用率。接着讨论了优先级任务,使不同优先级的任务得到合理调度。然后提出了缓存机制,通过环形缓存队列提升程序负载能力。Local Thread机制则通过预先创建线程减少创建和销毁线程的开销。Lock Free机制进一步减少了锁的竞争。容量动态调整机制根据任务负载动态调整线程数量。批量处理机制提高了任务处理效率。此外,还介绍了负载均衡、避免等待、预测优化、减少复制等策略。最后,任务组的设计便于管理和复用多任务。整体设计旨在提升线程池的性能和稳定性。
100 5
AI助理

你好,我是AI助理

可以解答问题、推荐解决方案等