Visual C++ 2008入门经典 第八章深入理解类 练习题 简单

// 第八章深入理解类 练习题2012-11-04
//.cpp: 主项目文件。


//第一题
/*#include "stdafx.h"
#include <iostream>
#include <string>
using namespace std;
using namespace System;
class ECS
{
private:
	int value;
	bool boolecs;
public:
	ECS(int va=0, bool ecs = false):value(va), boolecs(ecs){
	
	}
	void print();

	//重载运算符+
	ECS operator+(const ECS& e) const
	{
	     return ECS(e.value + value, boolecs || e.boolecs);
	}
	//重载运算符+
	ECS operator+(const int& i) const
	{
	    return ECS(value+i, boolecs);
	}
};
void ECS::print()
{
	if(boolecs){
	   cout<<"E";
	}
	cout<<this->value;
}

//重载全局运算符++
ECS operator+(const int& a, const ECS& ecs)
{
    return ecs + a;
}




int main(array<System::String ^> ^args)
{
	//这里的a=3直接为3,是用的默认构造函数吗?
	ECS a = 3, c;
	ECS b(5,true);

	cout<<"a=";
	a.print();
	cout<<endl;

	cout<<"b=";
	b.print();
	cout<<endl;

	c = a + b;
	cout<<"a + b = ";
	c.print();
	cout<<endl;

	c = 7 + b;
	cout<<"7 + b = ";
	c.print();
	cout<<endl;

	c = a + 9;
	cout<<"a + 9 = ";
	c.print();
	cout<<endl;

	c = 8 + a + 9 + b;
	cout<<"8 + a + 9 + b = ";
	c.print();
	cout<<endl;
    
	system("pause");
	return 0;
}*/

//第二题
/*#include "stdafx.h"
#include <iostream>
#include <string>
using namespace std;
using namespace System;

class IString
{
private:
	char* p;
	int length;
public:
	IString(const char* ch=0):p(0), length(0)
	{
		if(ch != 0){
		    length = strlen(ch);
			p = new char[length+1];
			strcpy_s(p, length+1, ch);	
		}
	}

	//复制构造函数
	IString(const IString& str)
	{
		//cout<<"str:"<<str<<endl;
		//妈的这里怎么判断是自己的呢
		//if(this === str){		
		//}
		//开始复制
		length = str.length;
		p = new char[length+1];
		strcpy_s(p,length +1, str.p);
	}

	//赋值运算符
	IString& operator=(const IString& str)
	{
	    length = str.length;
		delete p;
		p = new char[length+1];
		strcpy_s(p, length+1, str.p);
		return *this;
	}



	~IString(){
	   delete p;
	}
	
	void print()
	{
	    cout<<"p:"<<p<<" length:"<<length<<endl;
	}

};


int main(array<System::String ^> ^args)
{
	
	IString str("Hello");
	str.print();

    IString str1(str);
	str1.print();



	IString str2("Xlc");
	str2.print();

	IString str3;
	str3 = str2;
	str3.print();

    system("pause");
	return 0;
}*/


//第三题
/*#include "stdafx.h"
#include <iostream>
#include <string>
using namespace std;
using namespace System;

class IString
{
private:
	char* p;
	int length;
public:
	IString(const char* ch=0):p(0), length(0)
	{
		if(ch != 0){
		    length = strlen(ch);
			p = new char[length+1];
			strcpy_s(p, length+1, ch);	
		}
	}

	IString(const char ch, int len=1):p(0), length(0)
	{
	    length = len;
		if(length > 1){
		     p = new char[length+1];
			 memset(p, ch, length);
			 p[length] = '\0';
		}	
	}

	//另外一个构造函数
	IString(int i):p(0),length(0)
	{
	     char sTmp[20];
		 //_itoa_s(i,buffer,2,10);//10表示10进制2表示字符长度buffer表示存放结果
		 _itoa_s(i, sTmp, 20, 10);

		 cout<<"sTmp:"<<sTmp<<endl;

		 length = strlen(sTmp);
		 if(length > 0){
		     p = new char[length+1];
			 strcpy_s(p, length+1, sTmp);
		 }
	}


	//复制构造函数
	IString(const IString& str)
	{
		//cout<<"str:"<<str<<endl;
		//妈的这里怎么判断是自己的呢
		//if(this === str){		
		//}
		//开始复制
		length = str.length;
		p = new char[length+1];
		strcpy_s(p,length +1, str.p);
	}




	//赋值运算符
	IString& operator=(const IString& str)
	{
	    length = str.length;
		delete p;
		p = new char[length+1];
		strcpy_s(p, length+1, str.p);
		return *this;
	}
    ~IString(){
	   delete p;
	}
	
	void print()
	{
	    cout<<"p:"<<p<<" length:"<<length<<endl;
	}

};


int main(array<System::String ^> ^args)
{
	
	IString str("Hello");
	str.print();
    IString str1(str);
	str1.print();
	IString str2("Xlc");
	str2.print();
	IString str3;
	str3 = str2;
	str3.print();

	IString str4('V', 10);
	str4.print();

	IString str5(5555);
	str5.print();



    system("pause");
	return 0;
}
*/

//第四题
//我感觉不行，刚才也想到了，但没有用this==*str成功
/*#include "stdafx.h"
#include <iostream>
#include <string>
using namespace std;
using namespace System;

class IString
{
private:
	char* p;
	int length;
public:
	IString(const char* ch=0):p(0), length(0)
	{
		if(ch != 0){
		    length = strlen(ch);
			p = new char[length+1];
			strcpy_s(p, length+1, ch);	
		}
	}
	IString(const char ch, int len=1):p(0), length(0)
	{
	    length = len;
		if(length > 1){
		     p = new char[length+1];
			 memset(p, ch, length);
			 p[length] = '\0';
		}	
	}
	//另外一个构造函数
	IString(int i):p(0),length(0)
	{
	     char sTmp[20];
		 //_itoa_s(i,buffer,2,10);//10表示10进制2表示字符长度buffer表示存放结果
		 _itoa_s(i, sTmp, 20, 10);

		 cout<<"sTmp:"<<sTmp<<endl;

		 length = strlen(sTmp);
		 if(length > 0){
		     p = new char[length+1];
			 strcpy_s(p, length+1, sTmp);
		 }
	}
	//复制构造函数
	IString(const IString& str)
	{
		//cout<<"str:"<<str<<endl;
		//妈的这里怎么判断是自己的呢
		//if(this === str){		
		//}
		//开始复制
		length = str.length;
		p = new char[length+1];
		strcpy_s(p,length +1, str.p);
	}
	//赋值运算符
	IString& operator=(const IString& str)
	{
		//if(*this != str){ //这个刚才都没进去,*this是指当前对像的值了，而str只是一个IString&的引用
		if(this != &str){ //这里应该用this当前的地址不等于str的地址才对，&str取地址
			length = str.length;
			delete p;
			p = new char[length+1];
			strcpy_s(p, length+1, str.p);
		}
		return *this;		
	}
    ~IString(){
	   delete p;
	}	
	void print()
	{
	    cout<<"p:"<<p<<" length:"<<length<<endl;
	}
};


int main(array<System::String ^> ^args)
{
	
	IString str("Hello");
	
    str = str;
	str.print();


    system("pause");
	return 0;
}*/


//第五题
/*
#include "stdafx.h"
#include <iostream>
#include <string>
using namespace std;
using namespace System;

class IString
{
private:
	char* p;
	int length;
public:
	IString(const char* ch=0):p(0), length(0)
	{
		if(ch != 0){
		    length = strlen(ch);
			p = new char[length+1];
			strcpy_s(p, length+1, ch);	
		}
	}
	IString(const char ch, int len=1):p(0), length(0)
	{
	    length = len;
		if(length > 1){
		     p = new char[length+1];
			 memset(p, ch, length);
			 p[length] = '\0';
		}	
	}
	//另外一个构造函数
	IString(int i):p(0),length(0)
	{
	     char sTmp[20];
		 //_itoa_s(i,buffer,2,10);//10表示10进制2表示字符长度buffer表示存放结果
		 _itoa_s(i, sTmp, 20, 10);

		 cout<<"sTmp:"<<sTmp<<endl;

		 length = strlen(sTmp);
		 if(length > 0){
		     p = new char[length+1];
			 strcpy_s(p, length+1, sTmp);
		 }
	}
	//复制构造函数
	IString(const IString& str)
	{
		//cout<<"str:"<<str<<endl;
		//妈的这里怎么判断是自己的呢
		//if(this === str){		
		//}
		//开始复制
		length = str.length;
		p = new char[length+1];
		strcpy_s(p,length +1, str.p);
	}
	//赋值运算符
	IString& operator=(const IString& str)
	{
		//if(*this != str){ //这个刚才都没进去,*this是指当前对像的值了，而str只是一个IString&的引用
		if(this != &str){ //这里应该用this当前的地址不等于str的地址才对，&str取地址
			length = str.length;
			delete p;
			p = new char[length+1];
			strcpy_s(p, length+1, str.p);
		}
		return *this;		
	}

	//重载operator+()运算符
	IString operator+(const char* ch)
	{
		 //int len = strlen(ch);
		 //重新设置长度
		 //int _len = length+len; //两个字符串合并以后的长度
		 //char* temp = new char[_len]; //重新定义字符串指针
		 //当两个字符串合并到一起去
		 //int i=0;
		 //for(i=0; i<length; i++){
		 //    temp[i] = p[i];
		 //}
		 //for(int j=0; i<_len; j++, i++){
		 //     temp[i] = ch[j];
		 //}
		 //temp[_len] = '\0'; //合并成功
		 //cout<<"temp:"<<temp<<endl;
		 //return IString(temp);
		 
		 //上面是自己写的
		 //下面是答案上给的	     
		 return *this + IString(ch);
	}

	IString operator+(const IString& s)
	{
	      size_t _length = length + s.length + 1;
		  char* temp = new char[_length];
		  strcpy_s(temp, _length, p);   //把p复制到temp里面去
		  //cout<<"temp:"<<temp<<endl;
		  //strcpy_s(temp, _length, s.p); //这个也在智能了吧，直接把两个这么合并起来了,还知道第一次的p被加到了什么地方为止
		  //弄不懂这里样
		  //哥我错了，这里用的是strcat_s
		  strcat_s(temp,_length, s.p);
		  //cout<<"temp:"<<temp<<endl;
		  return IString(temp);
	}

	//重载+=
	IString& operator+=(const IString& str)
	{
	     *this = *this + str; //用当前对像+str,因为上面已经重新了该+运算符
		 return *this; //直接返回
	}


    ~IString(){
	   delete p;
	}	
	void print()
	{
	    cout<<"p:"<<p<<" length:"<<length<<endl;
	}
};


int main(array<System::String ^> ^args)
{
	
	IString str("Hello");

	IString str1 = str + " C++";
	str1.print();


	IString str2(" PHPchina");
	str += str2;
	str.print();
    system("pause");
	return 0;
}*/

//第六题
/*
#include "stdafx.h"
#include <iostream>
#include <string>
using namespace std;
using namespace System;
class CStack
{
public:
	CStack(int n=10); //构造函数
	~CStack();        //析造函数
	void push(int i); //追加数据
	int pop();
	void print();
private:
	int* pList;       //定义一个指针
	int size;         //指针长度
	int next;         //当前的索引值
};

//创建一个长度为n的int指定，保存到pList中去
CStack::CStack(int n):size(n),next(0)
{
	pList = new int[size];
}
CStack::~CStack()
{
    delete []pList; //清空pList指针
}


void CStack::push(int i)
{
	//当下一条指针小于99时，就还可以追加上去
	//next是指当前的索引值
	if(next < 99){
	    pList[next++] = i;
	}
}
//返回最后一条值
int CStack::pop()
{
    //cout<<"next:"<<next<<endl;
	return pList[--next];
	//这里的返回并没有把该地址去掉，而只是在next长度中减一了，不能读出来了
}

void CStack::print()
{
     cout<<'[';
	 //这里从最后开始循环到最前面
	 for(int i=next-1; i>=0; i--){
	       //cout<<"i="<<i<<' '<<pList[i];
		  cout<<' '<<pList[i];
	 }
	 cout<<"]"<<endl;
}


int main(array<System::String ^> ^args)
{

	CStack s(20);
	s.push(5);
	s.push(10);
	s.push(8);
	s.print();
	cout<<"最上面的数值为:"<<s.pop()<<endl;
	s.print();
    system("pause");
	return 0;
}*/


//第七题
/*#include "stdafx.h"
#include <iostream>
#include <string>
using namespace std;
using namespace System;
//ref 引用类
ref class Box
{
public:
	//默认构造函数
	Box()
	{
	     Box(1.0,1.0,1.0);
	}
	//带三个参数的构造函数
	Box(double lv, double wv, double hv)
	{
	     lv = lv <= 0.0 ? 1.0 : lv;
		 wv = wv <= 0.0 ? 1.0 : wv;
		 hv = hv <= 0.0 ? 1.0 : hv;

		 length = lv > wv ? lv : wv;
		 width = wv < lv ? wv : lv;
		 height = hv;
	}
	//计算面积
	double Volume()
	{
	    return length * width * height;
	}
	//属性（property）是很多时髦的面向对象编程语言提供的一种特性。通过属性，程序员可以如同访问成员数据一样访问一组
	property double Length	
	{
		double get(){ return length;}    
	}
	property double Width{
		double get(){ return width;}
	}
	property double Height{
		double get(){ return height;}
	}

	//重载运算符operator+
	Box^ operator+(Box^ box){
	    //返回一个新的Box引用类
		return gcnew Box(length > box->length ? length : box->length,
			             width > box->width ? width : box->width,
						 height + box->height);
	}

	//重载运算符operator/
	int operator/(Box^ box)
	{
	     int tc1 = 0;
		 int tc2 = 0;
		 //第一个的宽度和高度除以box的高宽，看能装下几个
		 tc1 = safe_cast<int>(length / box->length) * safe_cast<int>(width / box->width);

		 //第当前对像的高度除以box的宽度，用当前对像的宽度除以box的高度，看能装几个
		 tc2 = safe_cast<int>(length / box->width) * safe_cast<int>(width/box->length);
         //Console::WriteLine("tc1:{0} tc1:{1}", tc1, tc2);

		 //返回数量
		 return static_cast<int>(height/box->height) * (tc1 > tc2 ? tc1 : tc2);
	}

	//重载运算符operator*();
	Box^ operator*(int n)
	{
		if(n%2 == 0){ //如果是能被2整除的数
			//宽*2 然后高度加n/2
			return gcnew Box(length, 2.0*width, (n/2)*height);
		}else{
		    return gcnew Box(length, width, n*height);
		}
	}

	//重载%运算符
	double operator%(Box^ box)
	{
		 //先用this/box看当前this能装下几个box,然后来*每个box的面积
		 //用当前的面积减去
	     return Volume() - (this/box)*box->Volume(); 
	}

	//重载运算符>=
	bool operator>=(double value)
	{
	     return value >= this;
	}

	//重载<=
	bool operator<=(double value)
	{
	     return value >= this;     
	}

	//重载 > 
	static bool operator>(double value, Box^ box)
	{
	     return value > box->Volume();
	}
	static bool operator<(double value, Box^ box)
	{
	    return value < box->Volume();
	}

	static bool operator>(Box^ box, double value)
	{
	    return value < box->Volume();
	}
	static bool operator<(Box^ box, double value)
	{
	    return value > box->Volume();
	}

	static bool operator>=(double value, Box^ box)
	{
	    return value >= box->Volume();
	}
	static bool operator<=(double value, Box^ box)
	{
	    return value <= box->Volume();
	}

	static bool operator==(double value, Box^ box)
	{
	    return value == box->Volume();
	}
	static bool operator==(Box^ box, double value)
	{
	    return box->Volume() == value;
	}

	static Box^ operator*(int n, Box^ box)
	{
	    return box*n;
	}
private:
	double length;
	double width;
	double height;
};





int main(array<System::String ^> ^args)
{
	Box^ candy = gcnew Box(1.5, 1.0, 1.0);//一块糖的大小
	Box^ candyBox = gcnew Box(7.0, 4.5, 2.0); //一个小包装的大小
	Box^ carton = gcnew Box(30.0, 18.0, 18.0);//一个大礼盒的包装大小

	int numCandies = candyBox / candy; //一个小包装育装多少块	 
	int numCboxes = carton / candyBox;  //一个大礼盒能装多少小包装
	double space = carton % candyBox;   //还余下多少空间

	Console::WriteLine("candyBox能装 {0} 块糖果", numCandies);
	Console::WriteLine("carton能装 {0} candyBox包糖果", numCboxes);
	Console::WriteLine("carton能装 {0} candyBox包糖果后，还余下的空间为{1}", numCboxes, space);

	//长度
	for(double length=3.0; length<=7.5; length+=0.5){
		//宽度
		for(double width = 3.0; width<=5.0; width+=0.5){
		    //高度
			for(double height=1.0; height<= 2.5; height+=0.5){
			       Box^ tryBox = gcnew Box(length, width, height);
				   //装满以事余下的空间要小于一盒tryBox的空间
				   //要能正好装盒candy的数量
				   //并且装装的糖果块数要大于30块
				   if(carton % tryBox < tryBox->Volume() && tryBox % candy == 0.0 && tryBox/candy >= 30)
				   {
					   Console::WriteLine(L"\n\nTrial Box L={0} W={1} H={2}", tryBox->Length, tryBox->Width, tryBox->Height);
					   Console::WriteLine(L"一共能装 {0} 块糖果",tryBox/candy);
					   Console::WriteLine(L"一大礼箱能装 {0} 多少盒", carton/tryBox);
				   }
			}
		}
	}
    system("pause");
	return 0;
}*/


//第八题:
/*
#include "stdafx.h"
#include <iostream>
#include <string>
using namespace std;
using namespace System;
int main(array<System::String ^> ^args)
{
	const int MaxLength = 100;
	//开始处理输
	string str;	
	cout<<"请输入字符串吧(*结束):"<<endl;
	getline(cin,str, '*');
	cout<<"str:"<<str<<endl;


	
	//首先处理一下用户需要替换的单词
	string repString;
	cout<<"请输入你人替换的单词(*结束):"<<endl;
	getline(cin, repString, '*');
	cout<<"repString:"<<repString<<endl;

	//或者放入一个字符串数组中去
	size_t start = 0;
	size_t end = 0;
	size_t count = 0;
	string keyStrings[MaxLength];
    //关键词的数成已经完成
	while(true){
	     start = repString.find_first_not_of(' ', start);
		 if(start == string::npos){
		     break;
		 }
		 end = repString.find_first_of(' ', start);
		 if(end == string::npos){
		     end = repString.length();
		 }
		 if(count > MaxLength){
			 cout<<"超出了字符串数组的长度."<<endl;
		     break;
		 }
		 string s = repString.substr(start, end-start);
		 keyStrings[count++] = s;
		 start = end;
		 end = string::npos;
	}
	//开始查换和替换str字符串中出现的keyStrings的值
	for(size_t i=0; i<count; i++){
		 size_t _start = 0;
		 size_t _end=0;
	     cout<<keyStrings[i]<<endl;
		 while(true){
			 //没有理解这个函数哦
			 //find_first_of是当keyStrings[i]中出现的任意字符，就做数了，而不是字符串
			 _start = str.find_first_of(keyStrings[i], _start);
			 if(_start == string::npos){
			    break;
			 }
			 cout<<"_start:"<<_start<<endl;
			 _end = str.find_first_of(' ', _start);
			 if(_end == string::npos){
			    _end = str.length();
			 }
			 cout<<"开始位置是_start:"<<_start<<" _end:"<<_end<<endl;
			 string s = str.substr(_start, _end-_start);
			 cout<<"s:"<<s<<endl;
			 cout<<endl;
			 _start = _end;
			 _end = string::npos;
		 }
	}
    system("pause");
	return 0;
}
////////////////失败	
*/

//第八题答案上这么写的，练习一下
#include "stdafx.h"
#include <iostream>
#include <string>
using namespace std;
using namespace System;
int main(array<System::String ^> ^args)
{
	string text; //写义字符串text
	const size_t maxwords(100); //最大的字符长度100
	string words[maxwords];     //定义一个长度为100的字符串数组
	size_t wordcount(0);        //当前字符串的长度

	cout<<"输入要搜索的文本以#号结束"<<endl;
	getline(cin,text, '#'); //将输入的字符串保存到text中
	string textcopy(text);  //声明一个textcopy中然后把text初始给他

	//转换为小字
	for(size_t t = 0; t<textcopy.length(); t++)
	{
	     textcopy[t] = tolower(textcopy[t]);
	}

	while(true)
	{
	    cout<<"输入一个词，是要被替换的字符串或输入＃号结束："<<endl;
		cin>>words[wordcount]; //妈的保存到了wrods中去了
		if(words[wordcount] == "#"){ //如果为#退出
		   break;
		}
		//如果输入的长度已经大于了数组的容量,直接退出
		if(++wordcount == maxwords){
		   cout<<"已经超出了字符串数组的最大值"<<endl;
		   break;
		}
	}


	//开始循环查找所输入的需要替换的值了
	for(size_t i = 0; i<wordcount; i++)
	{
	     string wordcopy = words[i];
		 //对当前词转换为小写
		 for(size_t j=0; j<wordcopy.length(); j++){
		      wordcopy[i] = tolower(wordcopy[i]);
		 }

		 //应该是创建一个以wordcopy为长度的字符串，值为*
		 string asterisks(wordcopy.length(), '*');
		 cout<<"Each occurrence of: "<<words[i]<<"  will be replaced by  "<<asterisks<<" . "<<endl;

		 size_t position = 0;
		 //循环条件为在textcopy中查找wordcopy的位置，从position开始，直接为string::npos为止
		 while((position = textcopy.find(wordcopy, position)) != string::npos)
		 {
			 cout<<"position:"<<position<<endl;
			 //如果为位置为0时
			 if(position == 0){
				 //当当前的关键词长度与 text的长度一样时
				 if(position+wordcopy.length() == text.length())
				 {
					  text.replace(position, wordcopy.length(), asterisks); //替换
				 
				 //功能：如果参数是字母字符，函数返回非零值，否则返回零值。
				 //如果该值不为字母 检查过去的这个词不是字母
				 }else if(!isalpha(textcopy[position+wordcopy.length()])){
				      text.replace(position, wordcopy.length(), asterisks);
				 }  

			 //判断textcopy[position-1]的值是否为字母，如果不是字母执行
			 }else if(!isalpha(textcopy[position-1]))
			 {
				 if(position + wordcopy.length() == text.length())
				 {
				     text.replace(position, wordcopy.length(), asterisks);
				 }else if(!isalpha(textcopy[position+wordcopy.length()])){
				     text.replace(position, wordcopy.length(), asterisks);
				 }			 
			 }
			 position += wordcopy.length();
			 //然后移动position的长度
		 }
		 cout<<"处理后的原始字符串是现在:"<<text<<endl;
	}	

    system("pause");
	return 0;
}