重载 + == < []
时间: 2024-01-27 21:04:44 浏览: 18
重载是指在同一作用域内,对同一函数名进行多次定义,但是参数列表不同。重载可以包括运算符重载,函数重载等。
==是相等运算符的符号表示,在C++中可以使用运算符重载来定义自定义类型的相等运算符。
<是小于运算符的符号表示,在C++中可以使用运算符重载来定义自定义类型的小于运算符。
[]是下标运算符的符号表示,在C++中可以使用运算符重载来定义自定义类型的下标运算符。
相关问题
类中重载+=和=使用传入char *s
好的,那么根据你的需求,可以在类中重载+=和=运算符,使其能够接收一个 char* 类型的参数。
下面是示例代码:
```c++
#include <iostream>
#include <cstring>
using namespace std;
class MyString {
public:
MyString() {
m_length = 0;
m_data = new char[1];
m_data[0] = '\0';
}
MyString(const char* str) {
m_length = strlen(str);
m_data = new char[m_length + 1];
strcpy(m_data, str);
}
MyString(const MyString& other) {
m_length = other.m_length;
m_data = new char[m_length + 1];
strcpy(m_data, other.m_data);
}
~MyString() {
delete[] m_data;
}
void append(const char* str) {
int newLength = m_length + strlen(str);
char* newData = new char[newLength + 1];
strcpy(newData, m_data);
strcat(newData, str);
delete[] m_data;
m_data = newData;
m_length = newLength;
}
MyString& operator=(const char* str) {
if (m_data) {
delete[] m_data;
}
m_length = strlen(str);
m_data = new char[m_length + 1];
strcpy(m_data, str);
return *this;
}
MyString& operator+=(const char* str) {
append(str);
return *this;
}
friend ostream& operator<<(ostream& os, const MyString& str) {
os << str.m_data;
return os;
}
private:
int m_length;
char* m_data;
};
int main() {
MyString str1("Hello");
MyString str2 = "World";
str1 += "!";
cout << str1 << " " << str2 << endl;
return 0;
}
```
在以上代码中,我们定义了一个 MyString 类,其中重载了 = 和 += 运算符,使其能够接收一个 char* 类型的参数。具体实现时,我们使用了 strcpy、strcat 等字符串操作函数来完成字符串的复制和拼接。在 main 函数中,我们演示了如何使用该类对象进行字符串拼接。
定义自己的string类mystring,需要重载+=,=和[]
好的,下面是一个简单的示例代码实现:
```cpp
#include <iostream>
#include <cstring>
using namespace std;
class mystring {
private:
char* data;
int length;
public:
mystring() {
data = nullptr;
length = 0;
}
mystring(const char* str) {
length = strlen(str);
data = new char[length+1];
strcpy(data, str);
}
mystring(const mystring& str) {
length = str.length;
data = new char[length+1];
strcpy(data, str.data);
}
~mystring() {
if (data != nullptr) delete[] data;
}
mystring& operator=(const mystring& str) {
if (this == &str) return *this;
if (data != nullptr) delete[] data;
length = str.length;
data = new char[length+1];
strcpy(data, str.data);
return *this;
}
mystring& operator+=(const char* str) {
int len = strlen(str);
char* temp = new char[length+len+1];
strcpy(temp, data);
strcat(temp, str);
if (data != nullptr) delete[] data;
data = temp;
length += len;
return *this;
}
mystring& operator+=(const mystring& str) {
char* temp = new char[length+str.length+1];
strcpy(temp, data);
strcat(temp, str.data);
if (data != nullptr) delete[] data;
data = temp;
length += str.length;
return *this;
}
char& operator[](int index) {
return data[index];
}
const char& operator[](int index) const {
return data[index];
}
friend ostream& operator<<(ostream& os, const mystring& str) {
os << str.data;
return os;
}
};
int main() {
mystring str1("Hello");
mystring str2("World");
str1 += "!";
str1 += str2;
cout << str1 << endl;
cout << str1[0] << endl;
return 0;
}
```
在上述代码中,定义了一个`mystring`类,实现了默认构造函数、带`char*`参数的构造函数、拷贝构造函数、析构函数、赋值重载函数、`+=`重载函数、`[]`重载函数和输出流重载函数。其中,`+=`重载函数重载了`char*`和`mystring`两种类型的参数,`[]`重载函数实现了访问字符串中某个字符的功能。在主函数中,创建了两个`mystring`对象,分别为`str1`和`str2`,通过`+=`重载函数实现了字符串的拼接,最后通过`[]`重载函数输出了字符串中的第一个字符。