如何创建指向数组的指针并提供访问它的方法？

Question

1. 我必须创建 2 个 class 成员变量：

   一个。 指向字符数组的指针。

   湾。 字符串的长度

2. 创建成员函数以设置和获取所有字段。

3. 提供构造函数和析构函数。

4. 创建以下功能：

   一个。 从输入 position 返回符号；

   湾。 将字符串转换为字符。

5. 对子字符串进行 (+, +=, -, -=) 的重载操作。

到目前为止，这是我的代码：

字符串.h

class String
{
private:
    char m_symbol_array{};
    int m_string_length{};
public:
    String()
    {
        m_symbol_array;
        m_string_length;
    }
    //String(char symbol_array, int string_length);
    //void setString(char symbol_array, int string_length);
    void setSymbol_array();

    int getSymbol_array(char symbol_array) { return m_symbol_array; }
    int getString_length(int string_length) { return m_string_length; }

    void string_to_char();
    int return_symbol();

    //String operator+();
    //String operator-();
};

字符串.cpp

#include<iostream>
//#include<string>
//#include<cstring>
#include"String.h"

//String constructor

//String::String(char symbol_array='d', int string_length = 0)
//{
//  setString(  symbol_array, string_length);
//}
    //String member function
//void String::setString(char symbol_array, int string_length)
//{
//  m_symbol_array = symbol_array;
//  m_string_length = string_length;
//}

void String::setSymbol_array(char symbol_array)
{
    m_symbol_array = symbol_array;
}

void String::string_to_char()
{
    char* char_arr;
    cout << "Please, input the string ";
    string str_obj{};
    std::cin >> str_obj;
    //string str_obj("GeeksForGeeks");
    char_arr = &str_obj[0];
    cout << char_arr;

    //return 0;
}

//int String::return_symbol(){}

//String String::operator+(){}

//String String::operator-(){}

主文件

#include<iostream>
#include <cstring>
#include"String.h"

using namespace std;

//void string_to_char();

int main()
{
    /*String s(1,5);
    s.string_to_char();*/

    String first;
    char sd[5];

    first.getSymbol_array( *sd);
    //first.operator+();
    //String second{ 4,5 };
    //second.operator-();

    return 0;
}

当我试图使成员变量m_symbol_array成为指向数组的指针，然后为其提供 setter 和 getter 时，出现了问题。

Answer 1

让我们看几件事。 从您的包含文件中：

private:
    char m_symbol_array{};
    int m_string_length{};

两件事情。 首先，您需要一个指向字符数组的指针。 由于您在编译时不知道长度，所以它应该是 char *，而不是 char，如下所示：

 char * m_symbol_array;

接下来，让我们非常具体地改进初始化：

private:
    char * m_symbol_array{nullptr};
    int m_string_length{0};

也就是说 - 确保您的字符指针正确初始化为nullptr ，它是 C++ 变量，表示“尚未指向任何地方”，长度为 0。

现在，让我们看看这个：

String()
{
    m_symbol_array;
    m_string_length;
}

构造函数中的这两行没有意义。 删除它们。

在此之后，它变得棘手。 这几乎肯定不是您想要的，所以我正在更改签名：

void String::setSymbol_array(const char * symbol_array)
{
}

在 C++ 中，一系列字符可以用以下三种方式之一表示：

std::string theBestWay;
char * theSecondBestWay;
char theWorstWay[10];

theBestWay 是一个实现字符串的 class。 这是标准的一部分。 在某种程度上，您的作业是尝试编写 std::string 的一个版本。

但是您正在使用第二种方式来做到这一点——指向一系列字符的指针。 而且你会存储长度，所以当你处理它时，你可以摆弄它。

接下来要知道的是，当使用方法二或三时，你应该在最后有一个等于 0 的字符。不是“0”，而是零本身。 这就是 C 和 C++ 知道它已到达字符串末尾的方式。

所以，我不打算写代码，但我会解释得更好一点：

void String::setSymbol_array(const char * symbol_array)
{
     // if symbol_array == nullptr, then you should free
     // The allocated memory and set your m_ variable to nullptr;

     // Otherwise get the length of symbol_array (see strlen())
     // Then you can see if you already have enough space (plus one
     // for the 0-byte). If necessary, free the old memory and
     // allocate enough space, then use strcpy() to copy
     // the string.
}

我不会为你写的。 我在向你推荐正确的方向。 看看你能走多远。

Answer 2

您的String实现存在很多问题。 它需要完全重写。

考虑到语法更正、对 3/5/0 规则的处理等，请尝试类似以下的方法。

字符串.h

class String
{
private:
    char *m_symbol_array = nullptr;
    int m_string_length = 0;

public:
    String() = default;
    String(const char *symbol_array);
    String(const char *symbol_array, int string_length);
    String(const String &src);
    String(String &&src);
    ~String();

    String& operator=(String rhs);

    void setString(const char *symbol_array, int string_length);
    
    char* getSymbol_array() { return m_symbol_array; }
    const char* getSymbol_array() const { return m_symbol_array; }

    int getString_length() const { return m_string_length; }

    String& operator+=(const String &rhs);
    friend String operator+(const String &lhs, const String &rhs);
};

字符串.cpp

#include <iostream>
#include "String.h"
    
int str_length(const char *str)
{
    int length = 0;
    if (str) {
        while (str[length] != '\0') ++length;
    }
    return length;
}

//String constructors
    
String::String(const char *symbol_array)
    : String(symbol_array, str_length(symbol_array))
{
}

String::String(const char *symbol_array, int string_length)
    : String()
{
    setString(symbol_array, string_length);
}

String::String(const String &src)
    : String(src.m_symbol_array, src.m_string_length)
{
}

String::String(String &&src)
    : m_symbol_array(src.m_symbol_array), m_string_length(src.m_string_length)
{
    src.m_symbol_array = nullptr;
    src.m_string_length = 0;
}

//String destructor

String::~String()
{
    delete[] m_symbol_array;
}

//String member functions

String& String:operator=(String rhs)
{
    /*
    std::swap(m_symbol_array, rhs.m_symbol_array);
    std::swap(m_string_length, rhs.m_string_length);
    */

    char *old_symbol_array = m_symbol_array;
    int old_string_length = m_string_length;

    m_symbol_array = rhs.m_symbol_array;
    m_string_length = rhs.m_string_length;

    rhs.m_symbol_array = old_symbol_array;
    rhs.m_string_length = old_string_length;

    return *this;
}

void String::setString(const char *symbol_array, int string_length)
{
    char *new_symbol_array = new char[string_length + 1];
    for(int i = 0; i < string_length; ++i) {
        new_symbol_array[i] = symbol_array[i];
    }
    new_symbol_array[string_length] = '\0';

    delete[] m_symbol_array;
    m_symbol_array = new_symbol_array;
    m_string_length = string_length;
}

String& String::operator+=(const String &rhs)
{
    int new_string_length = m_string_length + rhs.m_string_length;
    char *new_symbol_array = new char[new_string_length + 1];

    for(int i = 0; i < m_string_length; ++i) {
        new_symbol_array[i] = m_symbol_array[i];
    }

    for(int i = 0; i < rhs.m_string_length; ++i) {
        new_symbol_array[m_string_length + i] = rhs.m_symbol_array[i];
    }

    delete[] m_symbol_array;
    m_symbol_array = new_symbol_array;
    m_string_length = new_string_length;

    return *this;
}

String operator+(const String &lhs, const String &rhs)
{
    /*
    String ret(lhs);
    ret += rhs;
    return ret;
    */

    int new_string_length = lhs.m_string_length + rhs.m_string_length;
    char *new_symbol_array = new char[new_string_length + 1];

    for(int i = 0; i < lhs.m_string_length; ++i) {
        new_symbol_array[i] = lhs.m_symbol_array[i];
    }

    for(int i = 0; i < rhs.m_string_length; ++i) {
        new_symbol_array[lhs.m_string_length + i] = rhs.m_symbol_array[i];
    }

    String ret;
    ret.m_symbol_array = new_symbol_array;
    ret.m_string_length = new_string_length;

    return ret;
}

我将把 rest 留给你来解决。

现在，话虽如此，鉴于您显示的String class，您的main()代码毫无意义。 您正在尝试使用整数而不是字符串来构造String对象。 您是否希望保存一个整数数组？ 或者以某种方式将整数转换为文本字符？ 我认为您需要重新阅读您的要求。 要么你的String被期望做你在这里展示的以外的事情，要么你的main()完全错误。