C++ C++；将const char*指针数组传递给对象

亲爱的飞越者：

向对象传递

常量char*[]

时遇到问题。情况如下

我有一个

类UlamScreen

，它包含一个带有多个字符串的

常量char*[]

UlamScreen

还包含一个对象

homeScreenMenu

class UlamScreen {
  const char* homeScreenText[5] = {"EVA dun", "Sabine", "TPU dun", "test Wout", 
  UlamScreenMenu homeScreenMenu;
};

class UlamScreenMenu {    
private:
  const char* _menuText[];

public:
  UlamScreenMenu(const char*[]);
  void drawMenu();
};

我想将

const char*[]

传递给

UlamScreenMenu

，以便在名为

void drawMenu

的成员函数中使用它，如下所示：

void UlamScreenMenu::drawMenu() {
  for (int i = 0; i < menuItems; i++) {
      tft.println(_menuText[i]);
  }
}

我原以为这样行得通，但由于某种原因，它行不通<代码>tft.println（_menuText[i]）与

无效绘图菜单一起使用

不会向我的tft屏幕发送任何内容。当我使用

tft.println（_menuText[I]）在UlamScreen类中，它可以完美地工作

为了清楚起见，我可以使用
ulamscreen菜单
类中的
tft
对象，因为其他函数，如
tft.drawRect（）
工作正常

这种传递
常量char*[]
的方法有什么问题？谢谢。在C++中，
< p>，不能声明类型<代码> const char *x[]]/>代码的成员变量，因为这将表示一个灵活的数组成员。灵活数组成员是一种C特性，允许结构的最后一个成员是大小不同的数组（例如，参见）。但是，支持在函数中使用类型为
const char*x[]
的参数，其含义与
const char**x
基本相同

如果您坚持使用类型为
constchar**
的成员，则必须在该类中处理内存管理。这意味着：负责分配、取消分配、复制、移动、复制分配和移动分配该类的对象（例如，cf）

如果-如评论中所建议的-您使用标准库集合，例如
std:：vector
，这些类将以可靠的方式为您完成所有这些工作。请参见以下示例，说明两者之间的区别：

请注意，C++版本可能甚至不会采用
const char*[]
-参数，而是直接采用
const std:：vector&x
-参数。但是我在构造函数中保留了
const char*[]
-参数，以便在两种变体中提供相同的接口：

// Variant 1: "old" C-style:
class Menu {
public:

    Menu(const char* x[], int length) {
        m_x = new const char*[length];
        m_length = length;
        for (int i=0; i<length; i++) {
            m_x[i] = x[i];
        }
    }

    ~Menu() {
        delete[] m_x;
    }

    // TODO: implement copy- and move constructors + copy- and move assignments
    // ...

    void print() {
        for (int i=0; i<m_length; i++) {
            std::cout << m_x[i] << std::endl;
        }
    }

private:
    const char** m_x = nullptr;
    int m_length;
};

#include <vector>

// Variant 2: a C++- way:
class Menu2 {
public:
    Menu2(const char* x[], int length) {
        m_x.assign(x, x+length);
    }

    void print() {
        for (auto s : m_x) {
            std::cout << s << std::endl;
        }
    }

    // Menu2 does not manage memory on its own, hence:
    // No special copy/move - constructors/assignments to be implemented.
    // No special destructor necessary
private:

    std::vector<const char*> m_x;
};

int main() {
    const char* x1[3] = {"one","two","three" };
    const char* x2[2] = {"eins","zwei" };

    // Variant 1
    Menu m1(x1, 3);
    m1.print();

    // Variant 2
    Menu2 m2(x2, 2);
    m2.print();
}

//变体1：“旧”C样式：
班级菜单{
公众：
菜单（常量字符*x[]，整数长度）{
m_x=新常量字符*[长度]；
m_长度=长度；
对于（int i=0；i）您不使用标准库类型（如
std:：string
和
std:：vector
）的原因是什么在标准C++中，
不是一个有效的声明，可以替代
std:：vector
，请参阅。传递
std:：array
或
std:：vector
而不是C样式的数组。感谢您详细的回答，它工作起来很有魅力！我使用了std:：vector。
// Variant 1: "old" C-style:
class Menu {
public:

    Menu(const char* x[], int length) {
        m_x = new const char*[length];
        m_length = length;
        for (int i=0; i<length; i++) {
            m_x[i] = x[i];
        }
    }

    ~Menu() {
        delete[] m_x;
    }

    // TODO: implement copy- and move constructors + copy- and move assignments
    // ...

    void print() {
        for (int i=0; i<m_length; i++) {
            std::cout << m_x[i] << std::endl;
        }
    }

private:
    const char** m_x = nullptr;
    int m_length;
};

#include <vector>

// Variant 2: a C++- way:
class Menu2 {
public:
    Menu2(const char* x[], int length) {
        m_x.assign(x, x+length);
    }

    void print() {
        for (auto s : m_x) {
            std::cout << s << std::endl;
        }
    }

    // Menu2 does not manage memory on its own, hence:
    // No special copy/move - constructors/assignments to be implemented.
    // No special destructor necessary
private:

    std::vector<const char*> m_x;
};

int main() {
    const char* x1[3] = {"one","two","three" };
    const char* x2[2] = {"eins","zwei" };

    // Variant 1
    Menu m1(x1, 3);
    m1.print();

    // Variant 2
    Menu2 m2(x2, 2);
    m2.print();
}