1.封装一个 File 类，用有私有成员 File* fp 实现以下功能

File f = "文件名" 要求打开该文件

f.write(string str) 要求将str数据写入文件中

string str = f.read(int size) 从文件中读取最多size个字节，并将读取到的数据返回

析构函数

#include <iostream>
#include <cstring>
#include <cstdlib>
#include <unistd.h>
#include <sstream>
#include <vector>
#include <memory>

using namespace std;

class File{
private:
	FILE* fp;
public:
	File(const char* filename)
	{
		fp=fopen(filename,"w+");
	}
	~File()
	{
		fclose(fp);
	}


	void write(const char* str)
	{
		fputs(str,fp);
	}


	string read(int size)
	{
		fseek(fp, 0, SEEK_SET);
		char buf[size+1];
		int x=fread(buf,1,size,fp);
		buf[x]='\0';
		string str=buf;
		return str;
	}
};

int main(int argc,const char** argv){
	File f("file.txt");
	f.write("zzy");
	string data=f.read(10);
	cout<<data<<endl;
}

输出结果：

2.封装一个 Mutex 互斥锁类

要求：

构造函数：初始化互斥锁，并选择互斥锁的种类

lock 上锁互斥锁

unlock 解锁互斥锁

析构函数，销毁互斥锁

并且开启一个线程测试该互斥锁

#include <iostream>
#include <cstring>
#include <cstdlib>
#include <unistd.h>
#include <sstream>
#include <vector>
#include <memory>

using namespace std;

class Mutex{
private:
	pthread_mutex_t m;
public:
	Mutex()
	{
		pthread_mutex_init(&m,NULL);
	}
	~Mutex()
	{
		pthread_mutex_destroy(&m);                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       
	}


	void lock()
	{
		pthread_mutex_lock(&m);
	}


	void unlock()
	{
		pthread_mutex_unlock(&m);
	}
};


Mutex M;

void* thread_main(void* arg)
{
	M.lock();
	int i;
	for(i=0;i<=100;i++)
	{
		cout<<i<<endl;
		usleep(10000);
	}
	M.unlock();
	return NULL;
}

int main(int argc,const char** argv){
	pthread_t id;
	pthread_create(&id,0,thread_main,0);
	pthread_join(id, NULL);
	return 0;
}

输出结果：