11.21c++中的函数

练习：

编写mystring类：拥有以下功能：

1.带参、无参构造函数，拷贝构造函数，析构函数

2.编写 append(const mystring r) 为当前字符串尾部，拼接新的字符串r

3.编写 isEqual(const mystring r) 判断当前字符串和 字符串 r是否相等

4.编写swap(另一个对象) 的函数，实现交换2个对象的字符串 mystring str = "hello" mystring ptr = "world" str.swap(ptr) str == "world",ptr == "hello"

5.添加 + 功能：本质就是append str1 = "hello" str2 = "world" str3 = str1 + str2 =="helloworld"

+= 功能

= 深拷贝功能

== 功能

!= 功能

++ 功能，字符串中所有字符的ASCII自增1

[] 下表运算符 operator[](int index) 返回该下标上的字符 str = "hello" cout << str[0] ;终端输出 

cout 输出mystring功能

cin 输入mystring功能

代码实现： 

#include <iostream>
#include <cstring>
#include <cstdlib>
using namespace std;
class mystring{
    char *buf;//基本数据类型

public:
    mystring(const char *str);//绑定一个构造函数my
    mystring();//绑定另外一个构造函数
    mystring(const mystring& r);
    ~mystring();//绑定一个析构函数
    void show();//绑定一个显示方法
    //设置字符串的方法，和获取当前字符串的方法，就是针对buf的set/get接口
   /* void setbuf(const char *buf){
        strcpy(this->buf,buf);
    }*/
    void setbuf(const mystring& r);
    //mystring str="hello";
    //mystring ptr;
    //1.ptr.setbuf(str);
    //2.ptr.setbuf("hello");//这里是隐式构造，---

    /*const char * getbuf(){
        return buf;
    }*/
    const char *getbuf()const;
    void append(const mystring& r);
    int isEqual(const mystring& r);
    void swap(mystring& r);
    //const char* operator+(const mystring& r);
    mystring operator+(const mystring& r);
    mystring& operator+=(const mystring& r);
    mystring& operator=(const mystring& r);//深拷贝赋值
    mystring& operator=(const mystring&& r);//浅拷贝赋值
    bool operator==(const mystring& r);
    bool operator!=(const mystring& r);
    mystring& operator++();//字符串中每个字符ASCII码值自增1
    char operator[](int index);
    friend ostream& operator<<(ostream& ,const mystring&);//输出友元函数
    friend istream& operator>>(istream& ,mystring&);//输入友元函数

};
mystring::mystring(){
    cout << "这是一个无参函数" << endl;
}
mystring::mystring(const char *str){
    int len=strlen(str);
    buf=(char *)calloc(1,len+1);
    strcpy(buf,str);
}
mystring::~mystring(){
    free(buf);
    buf=NULL;
}
mystring::mystring(const mystring& r){
    int len=strlen(r.buf);
    this->buf=(char *)calloc(1,len+1);
    strcpy(this->buf,r.buf);
}
void mystring::show(){
    cout << buf << endl;
}
void mystring::setbuf(const mystring& r){
    free(buf);
    int len=strlen(r.buf);
    this->buf=(char *)calloc(1,len+1);
    strcpy(this->buf,r.buf);
}
const char *mystring::getbuf() const{
    return buf;
}
void mystring::append(const mystring& r){
    int len=strlen(this->buf)+strlen(r.buf);//计算需要重新开辟的空间大小
    char *temp=(char *)calloc(1,len+1);
    strcpy(temp,this->buf);
    free(buf);//释放当前buf的空间
    strcat(temp,r.buf);
    this->buf=temp;
}
int mystring::isEqual(const mystring& r){
    return strcmp(this->buf,r.buf);
}
void mystring::swap(mystring& r){
    char *temp=r.buf;
    r.buf=this->buf;
    this->buf=temp;
}
//字符串加法运算符重载
/*const char* mystring::operator+(const mystring& r){
    int len=strlen(this->buf)+strlen(r.buf);//计算两个字符串长度和
    char *temp=(char *)calloc(1,len+1);//申请空间用于临时存放两个字符串
    strcpy(temp,this->buf);
    strcat(temp,r.buf);//追加
    return temp;//将更改后*this返回
}*/
mystring mystring::operator+(const mystring& r){
    int len=strlen(this->buf)+strlen(r.buf);//计算两个字符串长度和
    char *t=(char *)calloc(1,len+1);//申请空间用于临时存放两个字符串
    mystring temp=t;
    strcpy(temp.buf,this->buf);
    strcat(temp.buf,r.buf);
    return temp;
}
//字符串+=运算符重载
mystring& mystring::operator+=(const mystring& r){ 
    int len=strlen(this->buf)+strlen(r.buf);//计算两个字符串长度和
    char * temp=new char[len+1];
    //char *temp=(char *)calloc(1,len+1);//申请空间用于临时存放两个字符串
    //strcpy(temp,buf);
    memcpy(temp,buf,strlen(buf));  
    free(buf);//释放当前buf的空间
    strcat(temp,r.buf);//追加
    this->buf=temp;
   // cout <<buf;
    return *this;//将更改后*this返回
}
//字符串深拷贝赋值运算符重载
mystring& mystring::operator=(const mystring& r){
    int len=strlen(r.buf);//计算要拷贝字符串大小
    free(this->buf);//先释放当前buf空间
    char *temp=(char *)calloc(1,len+1);//先开辟堆空间
    strcpy(temp,r.buf);//将要拷贝内容拷贝到堆区
    this->buf=temp;//将当前buf指针指向temp指向的堆空间
    return *this;//返回当前自身
}
//字符串浅拷贝赋值运算符重载
mystring& mystring::operator=(const mystring&& r){
    this->buf=r.buf;
    return *this;//返回当前自身
}
//字符串判断是否相等运算符重载
bool mystring::operator==(const mystring& r){
    return (strcmp(this->buf,r.buf)==0);
}
bool mystring::operator!=(const mystring& r){
    return (strcmp(this->buf,r.buf)!=0);
}
//字符串每个字符ASCII码值自增1运算符重载
mystring& mystring::operator++(){
    int i=0;
    while(*(this->buf+i)){
        ++*(this->buf+i);
        i++;
    }
    return *this;
}
//数组下标引用运算符重载
char mystring::operator[](int index){
    return *(this->buf+index);
}
//字符串输出运算符重载
ostream& operator<<(ostream& out,const mystring& r){
    int i=0;
    while(*(r.buf+i)){
        out << *(r.buf+i);
		i++;
    }
    return out;
    //out << r.buf;
    return out;
}
//字符串输入运算符重载
istream& operator>>(istream& in,mystring& r){
    in >> r.buf;
	return in;
}
int main()
{
    /*mystring ptr;
    cout << sizeof(ptr) << endl;
    mystring str="hello world";
    str.show();
    str.setbuf("hello");
    cout << str.getbuf() << endl;
    ptr.setbuf(str);
    cout << ptr.getbuf() << endl;
    mystring str2="你好!";
    ptr.append(str2);
    cout << ptr.getbuf() << endl;
    ptr.append("123");
    cout << ptr.getbuf() << endl;
    if(ptr.isEqual("hello你好!123")==0){
        cout << "ptr==hello你好!123" << endl;
    }else {
        cout << "ptr!=123" << endl;
    }*/
    mystring s1="hello";
    mystring s2="world";
    mystring s3=s1+s2;
    cout << s3 << endl;
   mystring s4;
   s4=s2;
   cout << s4<< endl;
   s3 += s1;
    cout << s3<< endl;
    //s3 += s2;
   // s3.append("heoo");
    //mystring s4;

    //cout << s3 << endl;
    cout << (s3==s2) ;
   cout << (s1!=s2) << endl;
    ++s3;
    cout << s3 << endl;
    cout << s3[5]<< endl;
   // mystring s4;
    cin >> s4;
   cout << s4 << endl;


    return 0;
}

练习2： 

封装一个 msg 类
class msg{
private:
    key_t key;
    int msgid;
    long type;
public:
    struct msgbuf{
        long type;
        char text[512];            
    };
}
要求实现以下功能：
1:构造函数，创建一个消息队列，或者访问该消息队列
2:operator[] ：向[]中写入消息的类型，以确定消息向哪个频道中发送 或者 读取哪个频道的消息
3:snd(const string& data) 向消息队列的指定频道中发送消息，注意除了this指针之外，参数必须只能有一个 const string&
4:recv(int size) 从消息队列中读取消息，并返回读取到的消息，注意除了this指针之外，参数必须只能有一个 int size
5:析构函数，删除消息队列

代码实现：

send端： 

#include <iostream>
#include <cstring>
#include <cstdlib>
#include <myhead.h>
using namespace std;
class msg{
	private:
		key_t key;
		int msqid;
		long type;
		bool isblock;
	public:
		struct msgbuf{
			long type;
			char text[512];
		};
		msg(int msqid1=1,bool isblock=1);//构造函数
		msg& operator[](const long& type);//[]运算符重载
		void snd(const string& data);//向消息队列发送消息
		string recv(long type);//从消息队列中读取消息
		~msg();//析构函数，删除消息队列
};
msg::msg(int msqid1,bool isblock):msqid(msqid1),isblock(isblock){
	 key=ftok("/",'x');//创建一个key值
	if(key==-1){
		perror("ftok");
	}
	msqid=msgget(key,IPC_CREAT|0666);//创建一个消息队列，获得消息队列号
	if(msqid==-1){
		perror("msqid");
	}
}
msg& msg::operator[](const long& type){//[]运算符重载
	this->type=type;//确定要写入或读取的消息队列的序列号
	return *this;
}
void msg::snd(const string& data){//向消息队列发送消息
	msgbuf buf={0};
	buf.type=this->type;
	strcpy(buf.text,data.data());
	//cout << buf.text << endl;
	msgsnd(this->msqid,(void*)&buf,strlen(buf.text),0);//向消息队列中发送消息,阻塞形式发送
	cout << "消息已发送至消息队列" << endl;
}
string msg::recv(long type){//从消息队列中读取消息
	//char *buf=new char[size];
	//char buf[size]={0};
	msgbuf buf={0};
	if(isblock==1){
		msgrcv(this->msqid,(void*)&buf,sizeof(buf.text),type,0);//从消息队列中读取消息
	}else{
		msgrcv(this->msqid,(void *)&buf,sizeof(buf.text),type,IPC_NOWAIT);//非阻塞
	}
	//	cout << buf.text << endl;
	//string temp=buf.text;//c风格转c++
	//return temp;
	return buf.text;
}
msg::~msg(){//析构函数，删除消息队列
	msgctl(this->msqid,IPC_RMID,NULL);//删除消息队列
}
int main(int argc,const char ** argv)
{
	if(argc!=2){
		  cout << "请输入消息类型号" << endl;
		  return -1;
	}
	int type=atoi(argv[1]);
	msg msg1(1);
	while(1){
		cout << "请输入消息内容:";
		string data;
		cin >> data;
		msg1[type].snd(data);//发送数据
	}
	return 0;
}

recv端： 

#include <iostream>
#include <cstring>
#include <cstdlib>
#include <myhead.h>
using namespace std;
class msg{
	private:
		key_t key;
		int msqid;
		long type;
		bool isblock;
	public:
		struct msgbuf{
			long type;
			char text[512];
		};
		msg(int msqid1,bool isblock);//构造函数
		msg& operator[](const long& type);//[]运算符重载
		void snd(const string& data);//向消息队列发送消息
		string recv(long type);//从消息队列中读取消息
		~msg();//析构函数，删除消息队列
};
msg::msg(int msqid1=1,bool isblock=1):msqid(msqid1),isblock(isblock){
	 key=ftok("/",'x');//创建一个key值
	if(key==-1){
		perror("ftok");
	}
	 msqid=msgget(key,IPC_CREAT|0666);//创建一个消息队列，获得消息队列号
	if(msqid==-1){
		perror("msqid");
	}
}
msg& msg::operator[](const long& type){//[]运算符重载
	this->type=type;//确定要写入或读取的消息队列的序列号
	return *this;
}
void msg::snd(const string& data){//向消息队列发送消息
	msgbuf buf={0};
	buf.type=this->type;
	strcpy(buf.text,data.data());
	//cout << buf.text << endl;
	msgsnd(this->msqid,(void*)&buf,strlen(buf.text),0);//向消息队列中发送消息,阻塞形式发送
	cout << "消息已发送至消息队列" << endl;
}
string msg::recv(long type){//从消息队列中读取消息
	//char *buf=new char[size];
	//char buf[size]={0};
	msgbuf buf={0};
	if(isblock==1){
		msgrcv(this->msqid,(void*)&buf,sizeof(buf.text),type,0);//从消息队列中读取消息
	}else{
		msgrcv(this->msqid,(void *)&buf,sizeof(buf.text),type,IPC_NOWAIT);//非阻塞
	}
	//	cout << buf.text << endl;
	//string temp=buf.text;//c风格转c++
	//return temp;
	return buf.text;
}
msg::~msg(){//析构函数，删除消息队列
	msgctl(this->msqid,IPC_RMID,NULL);//删除消息队列
}
int main(int argc,const char ** argv)
{
	msg msg1(1);
	while(1){
		cout << "请输入获取消息类型号";
		int type;
		cin >> type;
		cout << msg1.recv(type) << endl;
	}
	return 0;
}