当前位置：极客教程 > C++语言 > C++ 问答 > 如何在C++中创建具有基本功能的自定义String类

如何在C++中创建具有基本功能的自定义String类

如何在C++中创建具有基本功能的自定义String类

在本文中，我们将创建具有与现有string类相同功能的自定义字符串类。

string类具有以下基本功能：

  1. 无参构造函数： 这将在堆中分配存储空间并将值分配为NULL字符。

  2. 只有一个参数的构造函数： 它接受一个指向字符的指针，或者我们可以说如果我们传递一个字符数组，则接受数组中第一个字符的指针，那么String类的构造函数将在相同大小的堆内存上为传递的数组分配存储空间，并将数组的内容复制到堆中已分配的存储空间中。它使用在cstring库中声明的strcpy()函数复制内容。

    在执行上述操作之前，它检查传递的参数是否是NULL指针，如果是，则会作为无参构造函数处理。

  3. 复制构造函数： 当从已创建的相同类型的对象创建任何对象时调用它，然后它执行深复制。它为将要创建的对象在堆上分配新空间，并复制传递的对象的内容（作为引用传递）。

  4. 移动构造函数： 它通常在通过直接初始化或复制初始化从相同类型的rvalue初始化（如a+b或return a）时调用。它接受自定义字符串类类型的对象的rvalue的引用。

下面是使用自定义字符串类 Mystring 的上述方法的实现：

//C++程序示例
#include <cstring>
#include <iostream>
using namespace std;
 
// 自定义字符串类
class Mystring {
 
    // 初始化字符数组
    char* str;
 
public:
    // 无参构造函数
    Mystring();
 
    // 1个参数的构造函数
    Mystring(char* val);
 
    // 复制构造函数
    Mystring(const Mystring& source);
 
    // 移动构造函数
    Mystring(Mystring&& source);
 
    // 析构函数
    ~Mystring() { delete str; }
};
 
// 函数示例构造函数
// 无参
Mystring::Mystring()
    : str{ nullptr }
{
    str = new char[1];
    str[0] = '\0';
}
 
// 函数示例构造函数
// 一个参数
Mystring::Mystring(char* val)
{
    if (val == nullptr) {
        str = new char[1];
        str[0] = '\0';
    }
 
    else {
 
        str = new char[strlen(val) + 1];
 
        // 使用strcpy复制val[]的字符
        strcpy(str, val);
        str[strlen(val)] = '\0';
 
        cout << "传递的字符串是："
             << str << endl;
    }
}
 
// 函数示例
// 复制构造函数
Mystring::Mystring(const Mystring& source)
{
    str = new char[strlen(source.str) + 1];
    strcpy(str, source.str);
    str[strlen(source.str)] = '\0';
}
 
// 函数示例
// 移动构造函数
Mystring::Mystring(Mystring&& source)
{
    str = source.str;
    source.str = nullptr;
}
 
// 驱动程序
int main()
{
    // 无参构造函数
    Mystring a;
 
    // 将字符串文字转换为// 字符数组
    char temp[] = "Hello";
 
    // 一个参数的构造函数
    Mystring b{ temp };
 
    // 复制构造函数
    Mystring c{ a };
 
    char temp1[] = "World";
 
    // 调用一个参数的构造函数，
    // 然后调用移动构造函数
    Mystring d{ Mystring{ temp } };
    return 0;
}
C++

输出：

传递的字符串是：Hello
传递的字符串是：Hello
C++

字符串类的一些更多功能：

  1. pop_back()： 从Mystring对象中删除最后一个元素。
  2. push_back(char ch)： 接受一个字符作为参数，并将其添加到Mystring对象的末尾。
  3. length()： 返回mystring的长度。
  4. copy()： 将mystring对象从给定位置（pos）和特定长度（len）复制到字符数组中。
  5. swap()： 它交换两个Mystring对象。
  6. 通过重载“+”运算符连接两个字符串：允许我们连接两个字符串。

以下是说明上述功能的程序：

// C++程序，展示上述功能

#include 
#include 
using namespace std;

// 类Mystring
class Mystring {

    // 流插入原型
    friend ostream&
    operator<<(ostream& os, const Mystring& obj);

    // 流提取原型
    friend istream& operator>>(istream& is, Mystring& obj);

    // “+”号运算符重载原型
    friend Mystring operator+(const Mystring& lhs, const Mystring& rhs);
    char* str;

public:
    // 无参构造函数
    Mystring();

    // 弹出末位元素函数
    void pop_bk();

    // 压入末位元素函数
    void push_bk(char a);

    // 获取字符串长度函数
    int get_length();

    // 从位置pos处复制长度为len的字符串函数
    void copy(char s[], int len, int pos);

    // 交换字符串函数
    void swp(Mystring& rhs);

    // 1个参数的构造函数
    Mystring(char* val);

    // 拷贝构造函数
    Mystring(const Mystring& source);

    // 移动构造函数
    Mystring(Mystring&& source);

    // 重载赋值运算符
    Mystring& operator=(const Mystring& rhs);

    // 析构函数
    ~Mystring() { delete str; }
};

// 重载赋值运算符
Mystring& Mystring::operator=(const Mystring& rhs)
{
    if (this == &rhs;)
        return *this;
    delete[] str;
    str = new char[strlen(rhs.str) + 1];
    strcpy(str, rhs.str);
    return *this;
}

// 重载加号运算符
Mystring operator+(const Mystring& lhs, const Mystring& rhs)
{
    int length = strlen(lhs.str) + strlen(rhs.str);

    char* buff = new char[length + 1];

    // 将字符串复制到buff[]
    strcpy(buff, lhs.str);
    strcat(buff, rhs.str);
    buff[length] = '\0';

    // 临时字符串
    Mystring temp{ buff };

    // 删除buff[]
    delete[] buff;

    // 返回连接后的字符串
    return temp;
}

// 重载流提取运算符
istream& operator>>(istream& is, Mystring& obj)
{
    char* buff = new char[1000];
    memset(&buff;[0], 0, sizeof(buff));
    is >> buff;
    obj = Mystring{ buff };
    delete[] buff;
    return is;
}

// 重载流插入运算符
ostream& operator<<(ostream& os, const Mystring& obj)
{
    os << obj.str;
    return os;
}

// 交换字符串的函数
void Mystring::swp(Mystring& rhs)
{
    Mystring temp{ rhs };
    rhs = *this;
    *this = temp;
}

// 复制字符串的函数
void Mystring::copy(char s[], int len, int pos)
{
    for (int i = 0; i < len; i++) {
        s[i] = str[pos + i];
    }
    s[len] = '\0';
}

// 压入元素的函数
void Mystring::push_bk(char a)
{
    // 获取字符串长度
    int length = strlen(str);

    char* buff = new char[length + 2];

    // 从str复制字符到buff[]
    for (int i = 0; i < length; i++) {
        buff[i] = str[i];
    }
    buff[length] = a;
    buff[length + 1] = '\0';

    // 将新的字符串与字符a分配给字符串str
    *this = Mystring{ buff };

    // 删除临时的buff[]
    delete[] buff;
}

// 弹出元素的函数
void Mystring::pop_bk()
{
    int length = strlen(str);
    char* buff = new char[length];

    // 从str复制字符到buff[]
    for (int i = 0; i < length - 1; i++)
        buff[i] = str[i];
    buff[length - 1] = '\0';

    // 将新的字符串与字符a分配给字符串str
    *this = Mystring{ buff };

    // 删除临时的buff[]
    delete[] buff;
}

// 获取字符串长度的函数int Mystring::get_length()
{
    return strlen(str);
}

// Constructor函数
Mystring::Mystring()
{
    str = new char[1];
    *str = '\0';
}

// 1个参数的构造函数
Mystring::Mystring(char* val)
{
    if (val == nullptr) {
        str = new char[1];
        *str = '\0';
    }
    else {
        str = new char[strlen(val) + 1];
        strcpy(str, val);
    }
}

// 拷贝构造函数
Mystring::Mystring(const Mystring& source)
    : str{ nullptr }
{
    str = new char[strlen(source.str) + 1];
    strcpy(str, source.str);
}

// 移动构造函数
Mystring::Mystring(Mystring&& source)
    : str{ source.str }
{
    source.str = nullptr;
}

// 主函数
int main()
{
    Mystring a{ "Hello" };
    Mystring b{ "World!" };

    cout << a << endl;
    cout << b << endl;

    a.swp(b);

    cout << "After swap\n";

    cout << a << endl;
    cout << b << endl;

    Mystring c;
    cout << "Enter a string: ";
    cin >> c;

    cout << "The string you entered is: " << c << endl;

    return 0;
}
没有参数
Mystring::Mystring()
    ：str {nullptr}
{
    str = new char [1];
    str [0] ='\0';
}
 
//展示构造函数的函数
//有一个参数
Mystring::Mystring(char* val)
{
    if (val == nullptr) {
        str = new char [1];
        str [0] ='\0';
    }
 
    else {
 
        str = new char [strlen(val) + 1];
 
        //使用strcpy复制val []的字符
        strcpy(str, val);
        str [strlen(val)] ='\0';
    }
}
 
//展示
//拷贝构造函数
Mystring::Mystring(const Mystring & amp; source)
{
    str = new char [strlen(source.str) + 1];
    strcpy(str, source.str);
}
 
//展示
//移动构造函数
Mystring::Mystring(Mystring & amp; & amp; source)
{
    str = source.str;
    source.str = nullptr;
}
 
//驱动程序代码
int main()
{
    //没有参数的构造函数
    Mystring a;
 
    //将字符串文字转换为
    //字符数组
    char temp [] = "你好";
 
    //有一个参数的构造函数
    Mystring b {temp};
 
    //拷贝构造函数
    Mystring c {a};
 
    char temp1 [] = "世界";
 
    //调用一个arg构造函数，
    //然后移动构造函数
    Mystring d {Mystring {temp}};
 
    //从中删除最后一个字符
    //Mystring b
    b.pop_bk();
 
    //打印字符串b
    cout << "Mystring b: "
         << b << endl;
 
    //添加Mystring b的最后一个字符
    b.push_bk('o');
 
    //打印字符串b
    cout << "Mystring b: "
         << b << endl;
 
    //打印字符串b的长度
    cout << "Mystring b的长度："
         << b << endl;
 
    char arr [80];
 
    //从
    //Mystring b的第0到3个字符的副本
    b.cpy(arr, 3,0);
 
    //打印字符串arr
    cout << "arr是："
         << arr << endl;
 
    //交换d和b
    d.swp(b);
 
    //打印d和b
    cout << d << ""
         << b << endl;
 
    //使用
    //重载'+'运算符来连接b和b
    d = b + b;
 
    //打印字符串d
    cout << "字符串d："
         << d << endl;
 
    返回0;
}
C++

输出:

Mystring b: Hell
Mystring b: Hello
Mystring b的长度: Hello
arr 是: Hel
Hello Hello
字符串 d: HelloHello
C++

Python教程

Python 教程

Python 教程
Tkinter 教程

Tkinter 教程
Pandas 教程

Pandas 教程
NumPy 教程

NumPy 教程
Flask 教程

Flask 教程
Django 教程

Django 教程
PySpark 教程

PySpark 教程
wxPython 教程

wxPython 教程
SymPy 教程

SymPy 教程
Seaborn 教程

Seaborn 教程
SciPy 教程

SciPy 教程
RxPY 教程

RxPY 教程
Pycharm 教程

Pycharm 教程
Pygame 教程

Pygame 教程
PyGTK 教程

PyGTK 教程
PyQt 教程

PyQt 教程
PyQt5 教程

PyQt5 教程
PyTorch 教程

PyTorch 教程
Matplotlib 教程

Matplotlib 教程
Web2py 教程

Web2py 教程
BeautifulSoup 教程

BeautifulSoup 教程

Java教程

Java 教程

Java 教程

Web教程

HTML 教程

HTML 教程
CSS 教程

CSS 教程
CSS3 教程

CSS3 教程
jQuery 教程

jQuery 教程
Ajax 教程

Ajax 教程
AngularJS 教程

AngularJS 教程
TypeScript 教程

TypeScript 教程
WordPress 教程

WordPress 教程
Laravel 教程

Laravel 教程
Next.js 教程

Next.js 教程
PhantomJS 教程

PhantomJS 教程
Three.js 教程

Three.js 教程
Underscore.JS 教程

Underscore.JS 教程
WebGL 教程

WebGL 教程
WebRTC 教程

WebRTC 教程
VueJS 教程

VueJS 教程

数据库教程

SQL 教程

SQL 教程
MySQL 教程

MySQL 教程
MongoDB 教程

MongoDB 教程
PostgreSQL 教程

PostgreSQL 教程
SQLite 教程

SQLite 教程
Redis 教程

Redis 教程
MariaDB 教程

MariaDB 教程

图形图像教程

Vulkan 教程

Vulkan 教程
OpenCV 教程

OpenCV 教程

大数据教程

R语言 教程

R语言 教程

开发工具教程

Git 教程

Git 教程
VSCode 教程

VSCode 教程
Docker 教程

Docker 教程
Gerrit 教程

Gerrit 教程
Excel 教程

Excel 教程

计算机教程

Go语言 教程

Go语言 教程
C++ 教程

C++ 教程

C++ 精品教程

登录

找回密码？

注册