C++每日编程

完成这个程序，对匿名对象的生命周期有了新认识。对这个程序进行了逐步的分析，见代码中每一步注释。

• string2.h

#pragma once
#ifndef STIRNG2_H_
#define STIRNG2_H_

#include 
#include 
#include 

class string2
{



private:
	char *str;
	int len;
	static int num_string;
	static const int CINLIM = 80;


public:
	string2(const char *); // 将字符串赋值给类对象
	string2();				// 默认构造函数
	string2(const string2 &);	// 初始化构造函数
	~string2();

	int length() const { return len; } // 获取字符串长度，写为内联函数
	string2 & operator=(const string2 &); // 重载等号运算符
	string2 & operator=(const char *);  // 对已有的类进行赋值
	string2  operator+(const string2 &);	// 两个类对象相加
	string2  operator+(const char *); // 类对象和char相加
	string2 &stringLow();		// 大小写转换
	string2 &stringUpper();
	int hasChar(char) const;	// 
	char & operator[](int i);


	// 
	friend bool operator<(const string2 &, const string2 &); // 比较两个字符串大小 
	friend bool operator>(const string2 &, const string2 &);
	friend bool operator==(const string2 &, const string2 &);

	friend std::ostream & operator<<(std::ostream &, const string2 &);
	friend std::istream & operator>>(std::istream &,  string2 &);
	friend string2 operator+(char *, const string2 &);

	static int HowMany();
};




#endif 

• string.cpp

#define _CRT_SECURE_NO_WARNINGS
#include "string2.h"
#include 
#include 

int string2::num_string = 0;
//private:
//	char *str;
//	int len;
//	static int num_string;
//	static const int CINLIM = 80;
//

//public:
//	string2(const char *); // 将字符串赋值给类对象 
string2::string2(const char *st)
{
	this->len = std::strlen(st);
	this->str = new char[this->len + 1];
	std::strcpy(this->str, st);
	this->num_string++;

}
//	string2();				// 默认构造函数
string2::string2()
{
	len = 4;
	str = new char[1];
	str[0] = '';
	num_string++;
}
//	string2(const string2 &);	// 初始化构造函数
string2::string2(const string2 &st)
{
	this->len = st.len;
	this->str = new char[len + 1];
	strcpy(this->str, st.str);
	num_string++;
}
//	~string2();
string2::~string2()
{
	std::cout << this->str << " 被析构" << std::endl;
	--this->num_string;
	delete[] this->str;
}

//	int length() const { return len; } // 获取字符串长度，写为内联函数

//	string2 & operator=(const string2 &); // 重载等号运算符
string2 & string2::operator=(const string2 &st)
{
	if (*this == st)
	{
		return *this;
	}
	else
	{
		delete[] this->str;
		this->len = st.len;
		this->str = new char[this->len + 1];
		std::strcpy(this->str, st.str);
		return *this;
	}
}
//	string2 & operator=(const char *);  // 对已有的类进行赋值
string2 & string2::operator=(const char *s)
{
	delete[] str;
	this->len = strlen(s);
	str = new char[len + 1];
	strcpy(str, s);
	return *this;

}
//		// 两个类对象相加,返回
string2  string2::operator+(const string2 &st)
{
	string2 str2;
	str2.len = this->len + st.len;
	str2.str = new char[str2.len + 1];
	std::strcat(strcpy(str2.str, this->str), st.str);
	return str2;
}
//	string2 & operator+(const char *); // 类对象和char相加
string2  string2::operator+(const char *s)
{
	string2 str2;
	str2.len = this->len + std::strlen(s);
	str2.str = new char[str2.len + 1];
	strcat(strcpy(str2.str, this->str), s);
	return str2;
}

//	string2 &stringLow();		// 大小写转换
string2 &string2::stringLow()
{
	for (int i = 0; i < this->len; i++)
	{
		if (std::islower(this->str[i]))
		{
			this->str[i] = toupper(this->str[i]);
		}
	}
	return *this;
}
//	string2 &stringUpper();
string2 & string2::stringUpper()
{
	for (int i = 0; i < this->len; i++)
	{
		if (std::isupper(this->str[i]))
		{
			this->str[i] = isupper(this->str[i]);
		}
	}
	return *this;

}
//	int hasChar(char) const;	// 
int string2::hasChar(char c) const
{
	int couter = 0;
	for (size_t i = 0; i < this->len; i++)
	{
		if (this->str[i] == c)
		{
			couter++;
		}
	}
	return couter;
}
//	char & operator[](int i);
char & string2::operator[](int i)
{
	return this->str[i];
}


	// 
	//friend bool operator<(const string2 &, const string2 &); // 比较两个字符串大小 

bool operator<(const string2 &str1, const string2 &str2)
{
	return (strcmp(str1.str, str2.str) < 0);
}
	//friend bool operator>(const string2 &, const string2 &);
bool operator>(const string2 &str1, const string2 &str2)
{
	return str1 < str2;
}
	//friend bool operator==(const string2 &, const string2 &);
 bool operator==(const string2 &str1, const string2 &str2)
{
	return (strcmp(str1.str, str2.str) == 0);
}
	//friend std::ostream & operator<<(std::ostream &, const string2 &);
 std::ostream & operator<<(std::ostream &os, const string2 &st)
 {
	 os << st.str <<'n';
	 return os;
 }
	//friend std::istream & operator>>(std::istream &, const string2 &);
 std::istream & operator>>(std::istream &is,  string2 &st)
 {
	 char temp[string2::CINLIM];
	 is.get(temp, string2::CINLIM); // 接收不多于CINLIM个字符
	 if (is) // 如果输入正确，最多赋予CINLIM个字符。
	 {
		 st = temp;// string2 & string2::operator=(const char *s)
	 }
	 while (is && is.get() != 'n') // 从缓冲区中删除多余的字符
	 {
		 continue;
	 }
	 return is;
 }
	//friend string2 operator+(char *, const string2 &);
 // 将两个字符串合并为一个字符串
 string2 operator+(char *s, const string2 &st)
 {
	 string2 str2;
	 str2.len = st.len + std::strlen(s);
	 str2.str = new char[str2.len + 1];
	 std::strcat(std::strcpy(str2.str, s), st.str);
	 std::cout << "str2临时对象是：" << str2.str << std::endl;
	 return str2; // 生成临时对象，调用这个函数，string2::string2(const string2 &st)
				// 临时对象声明周期，就是这行结束，然后调用~string2()
 }
 // 	static int HowMany();
int string2::HowMany()
{
	return num_string;

}

• usestring2.cpp

#include 
#include "string2.h"

using namespace std;
int main()
{
	{
		string2 s1("A"); // 调用string2(const char *); 
		string2 s2 = "B";  // string2::string2(const char *st)  // 对已有的类进行赋值
		string2 s3;		// string2::string2() 默认构造函数
		cout << s2;// friend std::ostream & operator<<(std::ostream &, const string2 &)
		cin >> s3; // C  std::istream & operator>>(std::istream &is,  string2 &st)
		s2 = "my name is " + s3; //  string2 operator+(char *s, const string2 &st)
		// 这个运算符先匹配形式，左边是字符串，右边是string类对象，符合重载+运算符，所以先调用上边+运算符重载函数
		// 调用string2 operator+(char *s, const string2 &st)结束后，生成一个临时对象，这个函数return时，此函数中的临时对象被析构掉，然后传给这个（"我的名字是" + s3）临时对象，然后开始调用string2 & string2::operator=(const string2 &st)，赋值运算符重载函数，这个函数将 （"我的名字是" + s3）这个临时对象“转正”，赋给s2，然后再调用析构函数，析构掉这个（"我的名字是" + s3）临时对象。
		// 
		cout << s2 << '.n';
		s2 = s2 + s1; // 先调用，string2  string2::operator+(const string2 &st)
						// 再调用，string2 & string2::operator=(const string2 &st)
						// 也是生成两个临时对象，转正后，被析构
		s2.stringLow();
		cout << s2 << endl;
		s1 = "D"; // 调用重载=  和 string2(const char *); 

		string2 rgb[3] = { string2(s1),string2("green"),string2("E") };
		cout << "输入颜色";
		string2 ans;
		bool success = false;
		while (cin >> ans)
		{
			ans.stringUpper();
			for (int i = 0; i < 3; i++)
			{
				if (ans == rgb[i])	//  bool operator==(const string2 &str1, const string2 &str2)
				{
					cout << "that is rightn";
					success = true;
					break;
				}
			}
			if (success) break;
			else
			{
				cout << "try again!n";
			}

		}

		
	
	}

	system("pause");
	return 0;

}