C++ | 湖北工业大学期末试卷

一、类型转换函数

operator char*() const

class String
{
private:
	char *str;									//指向动态数组的指针
	int size;		
	void Error(const char* c)const{cout<<c; exit(1);}//错误信息报告
public:
	String(const char *c="");		//默认构造+转换构造函数//请修改其中的错误①
	String(const String& s);					//复制构造
	~String(){delete[]str;}						//析构

	String& operator=(const char *c);			//转换赋值
	String& operator=(const String& s);			//复制赋值
operator char*() const	//成员转换函数 请修改其中的错误②
{ 
	   char *c=new char[size+1];
	   if(c==NULL)
		  Error("overflow");
	   strcpy(c,str);
	   return c;
}

	String operator+(const String& s)const;		//类串+类串
	String operator+(const char *c)const;		//类串+C
	friend String operator+(const char *c,const String& cs);//C串+类串 //请修改其中的错误③
		
		friend	 ostream& operator<<(ostream& ostr,const String &cs)  //请修改其中的错误④
{ 
       ostr<<cs.str;
		return ostr;
}

												//插入运算符函数
};

Operator char*()前面为什么不加返回值 char *,这个函数有什么作用 

operator char*() 是 String 类的成员转换函数，它的作用是将 String 对象转换为 char* 类型。

在函数的返回类型前面没有显示加上 char*，是因为在 C++ 中有一个隐式规定，如果成员转换函数的返回类型和名称都与转换的类型相同，那么可以省略返回类型。

例如，在这个代码中，operator char*() 返回的类型就是 char*，因此在返回类型前面没有显示加上 char*。

这个转换函数的作用是将 String 对象转换为 char* 类型，这样就可以直接使用 String 对象作为 char* 使用，比如在输出语句中可以直接输出 String 对象的内容。

举例子

// 成员转换函数（转换为浮点数类型）

operator float()

{ return static_cast<float>(numerator) / static_cast<float>(denominator); } 

二、下标访问符号

        const Type& operator[](int id)   const   

{

                if(id<0||id>size-1)

                        Error("id is illegal!\n");

                return data[id];

}

第一个const

修改后的 const Type& operator[](int id) const 函数返回的是一个常量引用，这样做是为了确保在常量对象上也可以使用取下标运算符并且不会修改对象的状态。

举个例子来解释这个原因。假设有一个 Vector 类，其中包含一个私有成员变量 data，它是一个动态数组。Vector 类提供了 operator[] 函数，用于访问数组中的元素。

下面我们来看一个例子：

const Vector v({1, 2, 3, 4, 5});  // 创建一个常量Vector对象

int x = v[2];  // 通过常量Vector对象调用operator[]，返回常量引用

在上面的例子中，我们通过常量的 v 对象调用 operator[] 函数，并将结果赋值给一个非常量的整型变量 x。由于 operator[] 函数返回的是一个常量引用，所以即使 v 是一个常量对象，我们仍然可以正常访问数组中的元素，并将其赋值给 x。

但是，如果 operator[] 返回的是一个非常量引用，则在上面的例子中编译会失败，因为我们试图将一个常量引用赋值给一个非常量的变量。

因此，为了在常量对象上也能够使用 operator[] 函数并且不修改对象的状态，我们需要将其返回值声明为常量引用。这样设计可以提高代码的灵活性，并允许在常量对象上使用取下标操作。

 

第二个const

在成员函数声明中，const 关键字应该放在参数列表后，指定该成员函数是一个常量成员函数，表示该函数不会修改对象的状态。 

三、 

class Date
{
    int day;
    static const int dys[];                    //静态成员数据，平常年每月对应天数
public:
//数据成员取值和赋值
            void Set_day(int d){day=d;}            //修改日

};
const int Date::dys[12]={31,28,31,30,31,30,31,31,30,31,30,31};//静态数据初始化

类外声明静态常量，要加命名空间！！！

 void Set_day(int d){day=d;}            //修改日

 day私有

不能用参数列表 ：day(d)

 四、

    cout<<*first<<'\t';

不是\0  !!!