C++-构造函数-接口

cpp 复制代码

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

using namespace std;

class Ms{
	private:
		char *p;
		int len;
	public:
		Ms(const char* str);
		Ms();
		~Ms();
		void copy(const Ms& r);
		void append(const Ms& r);
		void Show();
		bool compare(const Ms& r);
		void swap(Ms& r);
};

Ms::Ms(const char* str)
{
//	cout << "Ms单参构造函数" << endl;
	len=strlen(str);
	p=(char*)calloc(1,len+1);
	strcpy(p,str);
}

Ms::Ms()
{
//	cout << "Ms无参构造函数" << endl;
	p=nullptr;
	len=0;
}

Ms::~Ms()
{
	if(p!=NULL)
	{
		free(p);
	}
}

void Ms::copy(const Ms& r)//复制
{
	if(p!=NULL)
	{
		free(p);
	}
	len=r.len;
	p=(char*)calloc(1,len+1);
	strcpy(p,r.p);
}

void Ms::append(const Ms& r)//拼接
{
	len=len+r.len;
	char* backup=p;
	p=(char*)calloc(1,len+1);
	strcpy(p,backup);
	strcat(p,r.p);
	free(backup);
}

void Ms::Show()//输出
{
	cout << p << endl;
}

bool Ms::compare(const Ms& r)//比较
{
	return strcmp(p,r.p)==0;
}

void Ms::swap(Ms& r)//交换
{
	char* temp = p;
	p = r.p;
	r.p = temp;
}

int main(int argc,const char** argv){
	Ms str="dio";
	Ms ptr;
	
	ptr.copy("stand");
	ptr.Show();

	ptr.append("power");
	ptr.Show();

	if(ptr.compare(str)==1)
	{
		cout << "str和ptr一样" << endl;
	}else{
		cout << "str和ptr不一样" << endl;
	}

	ptr.swap(str);
	str.Show();
	ptr.Show();

}

cpp 复制代码

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

using namespace std;

class File{
private:
	FILE* fp;
public:
	File(const char* filename);//构造函数
	void Write(const string str);//写入
	string Read(int size);//读取
	~File();//析构函数
};

File::File(const char* filename)
{
	fp=fopen(filename,"w+");
	if(fp==NULL)
	{
		cout << "文件打开失败" << endl;
		return;
	}
}

void File::Write(const string str)
{
	const char* ptr =str.data();
	if(fwrite(ptr,strlen(ptr),1,fp)==0)
	{
		cout << "数据写入失败" << endl;
	}
}

string File::Read(int size)
{
	char ch[size+1]="";
	fseek(fp,0,SEEK_SET);
	if(fread(ch,size,1,fp)==0)
	{
		cout << "数据读取失败" << endl;
	}
	string ptr =ch;
	return ptr;
}

File::~File()
{
	if(fp!=NULL)
	{
		fclose(fp);
		fp=NULL;
	}
}

int main(int argc,const char** argv){
	File f="./1.txt";
	f.Write("WORLD");
	string buf=f.Read(3);
	cout << buf << endl;

}

cpp 复制代码

#include <iostream>
#include <pthread.h>
#include <unistd.h>
using namespace std;
 
enum kinds_mutex
{
	MUTEX_FAST,
	MUTEX_CHECK,
	MUTEX_RECURSION
};
 
class Mutex
{
	private:
		pthread_mutex_t mutex;
		enum kinds_mutex kinds;
	public:
		Mutex();
		void setMutex(enum kinds_mutex kinds);
		~Mutex();
		void lock();
		void unlock();
};
 
 
Mutex::Mutex()
{
	pthread_mutex_init(&mutex,NULL);
}
 
 
void Mutex::setMutex(enum kinds_mutex kinds)
{
	switch(kinds)
	{
		case MUTEX_FAST:
			{
				pthread_mutex_init(&mutex,NULL);
				break;
			}
		case MUTEX_CHECK:
			{
				pthread_mutexattr_t attr;
				pthread_mutexattr_init(&attr);
				pthread_mutexattr_settype(&attr,PTHREAD_MUTEX_ERRORCHECK_NP);
				pthread_mutex_init(&mutex,&attr);
				break;
			}
		case MUTEX_RECURSION:
			{
				pthread_mutexattr_t attr;
				pthread_mutexattr_init(&attr);
				pthread_mutexattr_settype(&attr,PTHREAD_MUTEX_RECURSIVE_NP);
				pthread_mutex_init(&mutex,&attr);
				break;
			}
 
	}
}
 
 
Mutex::~Mutex()
{
	pthread_mutex_destroy(&mutex);
}
 
 
void Mutex::lock()
{
	pthread_mutex_lock(&mutex);
}
 
 
void Mutex::unlock()
{
	pthread_mutex_unlock(&mutex);
}
 
 
Mutex m1,m2;
 
 
void* pthread_main(void* arg)
{
	while(1)
	{
		m2.lock();
		cout << "线程2"<<endl;
		sleep(1);
		m1.unlock();
	}
}
 
 
int main()
{
	pthread_t id;
	m1.setMutex(MUTEX_FAST);
	m2.setMutex(MUTEX_FAST);
	m2.lock();
	pthread_create(&id,0,pthread_main,NULL);
	pthread_detach(id);
	while(1)
	{
		m1.lock();
		cout<<"线程1"<<endl;
		sleep(1);
		m2.unlock();
	}
 
	return 0;
}