有比较函数是strcmp (参数1, 参数2)

 

参数是两个字符串，所在头文件是<string>

 

比较方法是按顺序依次比较参数1和参数2的第一个字符（看ASCII值）。

假如相同，则比较下一个；

假如参数1的比参数2的大，则返回1（正数）；

假如参数1的比参数2的小，则返回-1（负数）；

假如两个字符串完全一样，则返回0。

 

其原理是（这个我自己写的）：

int strcmp(const char* a, const char* b)
{
	while (*a == *b)
	{
		if (*a == *b == 0)return 0;
		a++, b++;
	}
	if (a > b) return 1;
	else if (a < b)	return -1;
}

注意：

①具体实现可能有所区别，但都是逐个判断；

②strcmp函数里的指针移动，不影响函数外的指针（因为这里是按值传递）。

 

 

 

可以通过比较函数，编写类的比较成员函数，或者是友元函数。

作用是，比较一个字符串和一个类对象（事实上是这个类对象的某个同类成员）的关系。

 

例如，代码：

bool operator<(char* word)
{	
	if (strcmp(name, word) < 0)return true;	//这里不能使用string类。注：string类的比较可以直接用>或者<或者==
	else return false;
}
bool operator>(char*word)
{
	return word < name;	//word<name和name>word是一个意思。假如前者为真，则后者为真，返回true
}
bool operator==(char*word)
{
	return (strcmp(name, word) == 0);	//如果等于0，则说明相等，返回true，否则false
}

注意：

①strcmp的两个参数，是char*类型，因此不能使用string类型进行比较；

 

②string类型的比较，可以直接使用 >、<、= 比较2个string类字符串的大小（返回true或者false，效果同这种方法）；

 

③为了方便，有必要加入友元函数进行比较，方法类似，如：

bool operator<(const char*word, Player& m)

{

return (m>word);

}

 

 

 

用中括号表示法访问字符：

中括号表示法其实就是“[]”这个符号。

在之前，假如有一个指针指向一个字符串char*a="abcd"; 那么a[0]=a；

char *a = new char[5];

strcpy_s(a, 5,"abcd");

a[0] = 'b';

cout << a << endl;

而这样一段代码中，a[0]可以把第一个字符改为字符'b'，

 

同样，可以用运算符重载的形式，将这种方法用作类（注意，中括号只能作为成员函数重载）。

 

如代码：

#include<iostream>
#include<string>
using namespace std;

class Man
{
	string fname;
	string lname;
public:
	Man() { fname = "aaa";lname = "bbb"; }	//为了方便，使用默认构造函数
	char&operator[](int m);
	void show();
};

int main()
{
	Man a;
	cout << a[0] << endl;	//a[0]是对象a的私有成员lname的第一个字母
	a[0] = 'c';
	a.show();
	system("pause");
	return 0;
}
void Man::show()
{
	cout << fname << ", " << lname << endl;
}
char&Man::operator[](int m)
{
	return lname[m];
}

显示：

b
aaa, cbb
请按任意键继续. . .

注意：

①a[0]中，a表示的是调用[]重载运算符的对象，0是参数。（可以参照指针指向字符串来理解）。

 

②因为返回的是引用char&，因此，这种方法可以修改私有成员的数据（a[0] = 'c';）；

 

③假如涉及到对象数组，例如Man b[3]，那么b[0]表示的则不是对象的第一个字符，而是表示的是b[0]这个对象。如果需要表示第一个字符，则使用b[0][0]。

 

④具体返回什么，可以根据需要自行定义。这里返回的是私有成员lname的某个字符（根据参数决定）。

 

 

假如这里面对是被const关键字所限定的对象（例如返回的、或者调用的对象是const所限定的const Man a;），那么则需要修改函数定义，具体需要看情况。

 

①假如是成员被const所限定，那么，首先肯定不能直接返回引用（因为引用涉及修改），可以返回被const所限定的引用、或者是返回副本（即比如说返回char类型）。

如：const string lname="bbb";

则函数定义修改为：

const char& Man::operator[](int m)

{

return lname[m];

}

这里的const表示返回值被const所限定，因此不能成为左值。

 

②假如是类对象被const所限定，如：const Man a;，这里表示对象的成员不能被修改。那么：

（1）需要有符合其的重载定义（成员函数在括号后加const表示限定成员不能被修改）；

（2）而返回值不能直接返回引用（因为这样可能导致会被修改），应返回普通类型或者是被const所限定的引用。

如：

const char& Man::operator[](int m)const

{

return lname[m];

}

第一个const表示返回值被限定，第二个const表示成员对象被限定。

 

 

③因此，如果要为被const限定的对象和不被const限定的对象（后者方便修改，且前提是返回值的成员没有被const限定）我们可以同时准备两个中括号运算符重载的定义，当遇见被const限定的对象时，则匹配const版的，否则匹配非const版的。

char& Man::operator[](int m)

{

return lname[m];

}

const char& Man::operator[](int m)const

{

return lname[m];

}

 

④另外，如果无需修改的话，可以直接使用const版的（放弃无const版），未被const限定的对象，也可以匹配const版的函数使用。

 

 

 

 

静态成员函数：

静态成员函数有点类似类的静态数据成员。

 

首先，静态成员函数的函数声明，必须包含关键字static；（但如果函数定义是独立的——指不属于任何一个类，而静态成员函数必须属于一个类，则不能使用关键字static）

 

其次，静态成员函数，在类外定义的话，无需再次加入static表示其是静态函数，只需要加上作用域运算符即可。例如类Man的静态成员函数static int show();在定义的时候，函数原型是int Man::show()这样

第三，不能通过  对象名.函数名  这样调用静态成员函数（因为他不属于某一个对象，属于整个类），也因此，无法使用this指针（因为this指针指向的是当前对象）。静态成员函数的调用方法是： 类名::静态成员函数名  ； 

最后，静态成员函数，只能访问同类里的静态成员（因为是他不属于对象，所以不能访问属于对象的非静态成员）。

这也就是为什么静态私有成员可以在函数外声明，而不能在类的非成员函数和非友元函数中访问。是因为静态成员属于整个类（而类定义不分配内存）。

 

 

而静态成员函数，可以用于设置类级（classwide）标记，以控制某些接口的行为。例如，类级标记可以控制显示类内容的方法所用的格式。

比如说在某种情况下，调用一次静态成员函数（可以用 类型::静态成员函数名  这样的方式），然后把静态数据成员+1，于是，某些成员函数以静态数据成员为判断条件的，则可以改变执行的代码）。

 

 

 

 

 

 

另外，静态私有数据成员之所以要在类定义和函数定义之外声明，两个原因：

①非成员、友元函数内部不能访问类的私有成员；

 

②成员函数、友元函数在能使用的时候，已经创建了类对象了，而多个类对象共享一个静态数据成员，因此需要先有静态数据成员，后有类对象才可以；（但若全局声明一个类对象，再初始化静态数据成员似乎也没有影响，不过这种对象在静态内存区域，好吧，我也搞不懂）

 

③不能和类在同一个头文件声明。是因为头文件可以多次重复引用，会导致多重声明。

而#ifndef  #endif 和#pragma once的作用，是防止在同一个文件内多次引用头文件，但对于多个文件引用同一个头文件，并没有作用。

 

 

 

赋值运算符的再次重载：

假如有构造函数：Man(const char* a);

那么若使用Man a = "abc"; 

编译器则会调用构造函数，创建一个临时对象（"abc"作为参数），然后使用复制构造函数，将临时对象的赋值给对象a，再然后调用析构函数，删除这个临时对象。

 

如代码：

#include<iostream>
#include<string>
using namespace std;
class Man
{
	string fname;
	string lname;
	static int a;
public:
	Man() { fname = "aaa";lname = ""; }	//为了方便，使用默认构造函数
	Man(const char* m);
	void show();
	~Man() { std::cout << "1" << std::endl; }
};

int main()
{
	Man a;
	a = "aaa";
	system("pause");
	return 0;
}


void Man::show()
{
	cout << fname << ", " << lname << endl;
}

Man::Man(const char* m)
{
	lname = m;
}

显示：

1
请按任意键继续. . .

 

这里是1，就表示析构函数被调用了，否则无显示。

 

当类对象比较小的时候（成员很少），可能没什么大的影响。但若类成员比较多（比如有100个），那么就会影响程序效率（因为会调用构造函数生成临时对象，还要再调用析构函数删除这个对象）。

 

因此，可以考虑重载赋值运算符，参数为const char*

 

新的运算符重载函数定义为：

int Man::operator=(const char*m)

{

lname = m;

return 1;

}

 

此时，重新运行程序，这次便无任何显示了。注意，假如是char*指针，则不能直接用lname=m这种形式，而是应通过delete 和new来进行。

 

 

另外，之所以需要有返回值，是因为赋值运算符的表达式本身就有值，例如：

cout<< (a=0) <<endl;  便会显示0，而 cout<< (a=100) <<endl; 则会显示100。而cout << (a = 'b') << endl;则显示的为字符b。

 

也就是说，其输入什么，在原本的赋值运算符中，其返回值便是什么。

 

而这里我们自定义的赋值运算符重载，返回值可以由我们自己决定。

 

 

 

以上便是类定义的优化，现我根据书上更改后的类声明，自行编写类定义，然后用书上给的程序进行测试。

#ifndef STRING1_H_

#define STRING1_H_

#include<iostream>

using std::ostream;

using std::istream;

 

class String

{

private:

char * std;

int len;

static int num_strings;

static const int CINLIM = 80;

public:

String(const char * s);

String();

String(const String &);

~String();

int length()const {return len;}

String & operator=(const String &);

String & operator=(const char*);

char & operator[](int i);

const char & operator[] (int i) const;

friend bool operator<(const String &st, const String& st2);

friend bool operator>(const String &st1, const String &st2);

friend bool operator==(const String &st, const String &st2);

friend ostream & operator<<(ostream & os, const String &st);

friend istream & operator>>(istream & is, String &st);

statici nt HowMany();

}；

#endif

 

以上是类定义，

 

 

现将完成程序如下：

//1.h 头文件，类定义
#ifndef STRING1_H_
#define STRING1_H_
#include<iostream>
using std::ostream;
using std::istream;


class String
{
private:
	char * std;
	int len;
	static int num_strings;
	static const int CINLIM = 80;	//输入限制
public:
	String(const char * s);
	String();
	String(const String &);
	~String();
	int length()const { return len; }	//返回字符串长度
	String & operator=(const String &);
	String & operator=(const char*);
	char & operator[](int i);
	const char & operator[] (int i) const;
	friend bool operator<(const String &st, const String& st2);
	friend bool operator>(const String &st1, const String &st2);
	friend bool operator==(const String &st, const String &st2);
	friend ostream & operator<<(ostream & os, const String &st);
	friend istream & operator>>(istream & is, String &st);
	static int HowMany();
};
#endif

//2.cpp 类的成员函数定义
#include<iostream>
#include"1.h"


String::String(const char * s)	//构造函数，用于将字符串作为参数
{
	len = strlen(s);
	std = new char[len + 1];
	strcpy_s(std, len + 1, s);
	num_strings++;	//计数器+1
}
String::String()	//默认构造函数
{
	len = 6;
	std = new char[len + 1];
	strcpy_s(std, len + 1, "未命名");
	num_strings++;
}
String::String(const String & m)	//复制构造函数，新建一个对象，并将其初始化为同类现有对象时调用，需要增加计数器
{
	len = m.len;
	std = new char[len + 1];
	strcpy_s(std, len + 1, m.std);
	num_strings++;
}
String::~String()	//析构函数，需要delete对象new出来的动态内存
{
	delete[]std;
	num_strings--;
}
String & String::operator=(const String & m)	//赋值运算符重载，无需增加计数器
{
	delete[]std;	//因为是已存在对象，然后下面要new，所以这里需要先delete
	len = m.len;
	std = new char[len + 1];
	strcpy_s(std, len + 1, m.std);
	return *this;
}
String & String::operator=(const char*m)	//赋值运算符重载，用于将字符串赋给类对象时调用，不增加计数器，因为这个用来避免创造临时对象
{
if (*this == m)return *this;	//防止将自己赋值给自己
	delete[]std;	//已存在对象，下面要new，因此delete
	len = strlen(m);
	std = new char[len + 1];
	strcpy_s(std, len + 1, m);
	return *this;
}
char & String::operator[](int i)	//中括号运算符重载，用于返回第i个字符
{
	return std[i];
}
const char & String::operator[] (int i) const	//中括号运算符重载，用于返回第i个字符，面向被const限定对象
{
	return std[i];
}
bool operator<(const String &st, const String& st2)	//用于比较类对象大小（实质上是比较类对象的字符串的数值大小——逐个比较）
{
	return (strcmp(st.std, st2.std) < 0);
}
bool operator>(const String &st1, const String &st2)
{
	return st2 < st1;
}
bool operator==(const String &st, const String &st2)
{
	return (strcmp(st.std,st2.std) == 0);
}
ostream & operator<<(ostream & os, const String &st)	//输出运算符重载
{
	os << st.std << "的长度是：" << st.len;
	return os;
}
istream & operator>>(istream & is, String &st)	//输入运算符重载
{
	delete[]st.std;
	char *q = new char[100];	//用一个间接的储存输入的内容
	is.get(q, String::CINLIM);
	while (is.get() != '\n')is.get();	//由于要求清除换行符，所以不能直接用is>>q这种形式，需要读取掉换行符。
	st.len = strlen(q);
	st.std = new char[st.len + 1];
	strcpy_s(st.std, st.len + 1, q);	//然后复制进去
	delete[]q;	//删除这个间接的

	return is;
}
int String::HowMany()	//返回当前对象数量，注意，这里的定义不再加static表示是静态成员函数
{
	return num_strings;
}

//1.cpp，用于测试
#include<iostream>
#include"1.h"
const int ArSize = 10;
const int MaxLen = 81;
int String::num_strings = 0;	//静态变量

int main()
{
	using std::cout;
	using std::cin;
	using std::endl;
	String name;
	cout << "Hi,what's your name?\n>>";
	cin >> name;

	cout << name << ", please enter up to " << ArSize << " short sayings <empty line to quit>:\n";
	String sayings[ArSize];
	char temp[MaxLen];
	int i;
	for (i = 0;i<ArSize;i++)
	{
		cout << i + 1 << ": ";
		cin.get(temp, MaxLen);
		while (cin && cin.get() != '\n')
			continue;
		if (!cin || temp[0] == '\0')
			break;
		else
			sayings[i] = temp;
	}
	int total = i;
	if (total>0)
	{
		cout << "Here are your sayings:\n";
		for (i = 0;i < total; i++)
			cout << sayings[i][0] << ": " << sayings[i] << endl;

		int shortest = 0;
		int first = 0;
		for (int i = 1;i<total;i++)
		{
			if (sayings[i].length()<sayings[shortest].length())
				shortest = i;
			if (sayings[i]<sayings[first])
				first = i;
		}
		cout << "Shortest saying:\n" << sayings[shortest] << endl;
		cout << "First alphabetically:\n" << sayings[first] << endl;
		cout << "This program used " << String::HowMany() << " String objects. Bye.\n";
	}
	else
		cout << "No input! Bye.\n";
	system("pause");
	return 0;
}

 

测试结果：

Hi,what's your name?
>>wd
wd的长度是：2, please enter up to 10 short sayings <empty line to quit>:
1: asda
2: befbe
3: qwwqfwqf
4: fdvfdvav
5: avavdasv
6: szccvdv
7: ththeth
8: q
9: fdgafg
10: rgerg
Here are your sayings:
a: asda的长度是：4
b: befbe的长度是：5
q: qwwqfwqf的长度是：8
f: fdvfdvav的长度是：8
a: avavdasv的长度是：8
s: szccvdv的长度是：7
t: ththeth的长度是：7
q: q的长度是：1
f: fdgafg的长度是：6
r: rgerg的长度是：5
Shortest saying:
q的长度是：1
First alphabetically:
asda的长度是：4
This program used 11 String objects. Bye.
请按任意键继续. . .

 

 

总结：

①犯错的一个地方在于：istream & operator>>(istream & is, String &st) //输入运算符重载   这个函数，只记得delete，但忘记new。因此退出程序时会出错，补充后ok。

 

②在①函数中，第一次未添加while (is.get() != '\n')is.get();出错，表现是未读取换行符。添加用于读取换行符后正常。

 

③没注意到原代码是在类成员函数定义文件中声明的静态变量，导致出错一次。在1.cpp文件中补充后正常。

 

④假如输入空行提前结束输入，会导致依然显示11 String objects，原因在于测试程序的循环是这样的，会要求建立10个新对象，再加上String name这个对象，因此共计11个。

 

⑤另一个错误在于，在赋值运算符重载时（面向类对象的），忘记加入面对自身时的条件判断了。这个错误会导致假如把自己赋值给自己，可能会出错的问题。