检查值是否确实存在于动态数组中？c++； 我想知道C++中是否有一种方法来检查动态数组的值是否真的存在。 int *x = new int[5];

好的，我认为默认情况下x的每个值都是0。但是，问题是，当我用值填充它时，实际上可能会输入0。因此，这将导致混淆，即什么告诉我们该值是否真的存在（0似乎是告诉我们它为NULL的惯用法，但在这种特殊情况下，我不能使用该惯用法，因为0可能是给定给我的值）

---

是否有其他方法检查动态数组中的值是否未定义？

如果它是动态分配的，它将不会为您归零；必须通过将所有条目设置为某个默认值来初始化数组。如果0是一个有效的条目，那么考虑使用否定的条目。如果所有正负值都是有效项，则考虑使用包含整数值的结构，并将布尔标志初始化为false。 在C中，这将是：

typedef struct {
    bool valid;
    int  value;
} node;

node x[] = new node[5];

---

如果它是动态分配的，它不会为您归零；必须通过将所有条目设置为某个默认值来初始化数组。如果0是一个有效的条目，那么考虑使用否定的条目。如果所有正负值都是有效项，则考虑使用包含整数值的结构，并将布尔标志初始化为false。 在C中，这将是：

typedef struct {
    bool valid;
    int  value;
} node;

node x[] = new node[5];

---

如果你不能牺牲一个值，比如最小的负值或最大的正值

int

，来表示“未设置”，你需要跟踪侧边设置的内容。在C++中，你可以使用<代码> STD:：向量< /代码>：

int*x=newint[5]；
std：：向量isSet（5，假）；
如果（！isSet[3]）{
x[3]=123；
isSet[3]=真；
}

如果您不能牺牲一个值，比如最小的负数或最大的正数

int

，表示“未设置”，则需要跟踪侧边设置的内容。在C++中，你可以使用<代码> STD:：向量< /代码>：

int*x=newint[5]；
std：：向量isSet（5，假）；
如果（！isSet[3]）{
x[3]=123；
isSet[3]=真；
}

首先，正如乔纳森所说，不能保证数组将被初始化为

0

。您可以单独初始化它，或者使用

int*x=newint[5]（）这将为您执行初始化

至于你如何知道哪些是有效的。最简单的方法是存储结构而不是
int
s。大概是这样的：

struct T {
    T() : valid(false), value(0) {
    }

    bool valid;
    int  value;
};

T *p = new T[5]; // each element will be initialized to false/0 because T has a constructor.

struct T {
    T() : valid(false), value(0) {
    }

    T &operator=(int x) {
        valid = true;
        value = x;
        return *this;
    }

    bool valid;
    int  value;
};

T *p = new T[5]; // each element will be initialized to false/0 because T has a 
p[1] = 10;       // p[1] is now true/10

#include <vector>

...

    std::vector<int> x();
    x.resize(5);

std::map<int, int> x;
x[0] = 10;
x[2] = 123;
// indexes 0 and 2 are set, the rest do not exist.

然后你可以做：

p[0].value = 10;
p[0].valid = true;

等等

编辑：
作为一个更高级的选项，您可以使用运算符重载来自动设置
有效
标志，如下所示：

struct T {
    T() : valid(false), value(0) {
    }

    bool valid;
    int  value;
};

T *p = new T[5]; // each element will be initialized to false/0 because T has a constructor.

struct T {
    T() : valid(false), value(0) {
    }

    T &operator=(int x) {
        valid = true;
        value = x;
        return *this;
    }

    bool valid;
    int  value;
};

T *p = new T[5]; // each element will be initialized to false/0 because T has a 
p[1] = 10;       // p[1] is now true/10

#include <vector>

...

    std::vector<int> x();
    x.resize(5);

std::map<int, int> x;
x[0] = 10;
x[2] = 123;
// indexes 0 and 2 are set, the rest do not exist.

基本上，为元素指定一个整数值将自动将其标记为有效。虽然在这个特定的示例中，我没有演示如何将值“取消设置”为“无效”。这可能对您的用例或编码风格有意义，也可能没有意义，只是一些值得思考的东西。
首先，正如Jonathon所说，不能保证数组将被初始化为
0
。您可以单独初始化它，或者使用
int*x=newint[5]（）这将为您执行初始化

至于你如何知道哪些是有效的。最简单的方法是存储结构而不是
int
s。大概是这样的：

struct T {
    T() : valid(false), value(0) {
    }

    bool valid;
    int  value;
};

T *p = new T[5]; // each element will be initialized to false/0 because T has a constructor.

struct T {
    T() : valid(false), value(0) {
    }

    T &operator=(int x) {
        valid = true;
        value = x;
        return *this;
    }

    bool valid;
    int  value;
};

T *p = new T[5]; // each element will be initialized to false/0 because T has a 
p[1] = 10;       // p[1] is now true/10

#include <vector>

...

    std::vector<int> x();
    x.resize(5);

std::map<int, int> x;
x[0] = 10;
x[2] = 123;
// indexes 0 and 2 are set, the rest do not exist.

然后你可以做：

p[0].value = 10;
p[0].valid = true;

等等

编辑：
作为一个更高级的选项，您可以使用运算符重载来自动设置
有效
标志，如下所示：

struct T {
    T() : valid(false), value(0) {
    }

    bool valid;
    int  value;
};

T *p = new T[5]; // each element will be initialized to false/0 because T has a constructor.

struct T {
    T() : valid(false), value(0) {
    }

    T &operator=(int x) {
        valid = true;
        value = x;
        return *this;
    }

    bool valid;
    int  value;
};

T *p = new T[5]; // each element will be initialized to false/0 because T has a 
p[1] = 10;       // p[1] is now true/10

#include <vector>

...

    std::vector<int> x();
    x.resize(5);

std::map<int, int> x;
x[0] = 10;
x[2] = 123;
// indexes 0 and 2 are set, the rest do not exist.

基本上，为元素指定一个整数值将自动将其标记为有效。虽然在这个特定的示例中，我没有演示如何将值“取消设置”为“无效”。这可能对您的用例或编码风格有意义，也可能没有意义，只是一些值得思考的东西。
如果您要使用的值是密集/连续的，请使用
std:：vector
（其
size（）
成员将告诉您当前有多少项是有效的）。如果值是稀疏的，则使用
std:：set

无论哪种方式，你最好忘记新的T[size]
根本就存在，更不用说让自己陷入实际使用它的疯狂状态。
如果你要使用的值是密集/连续的，那么使用
std:：vector
（其
size（）
member将告诉您当前有多少项有效）。如果值是稀疏的，则使用
std:：set

不管怎样，你最好忘记新的T[size]

根本就存在，更不用说让自己陷入实际使用它的疯狂状态了。

我不会使用动态数组来完成这项工作，因为正确管理资源涉及到许多复杂的问题。在我看来，您应该浏览一下

std:：vector

，这会使您的代码有点像这样：

struct T {
    T() : valid(false), value(0) {
    }

    bool valid;
    int  value;
};

T *p = new T[5]; // each element will be initialized to false/0 because T has a constructor.

struct T {
    T() : valid(false), value(0) {
    }

    T &operator=(int x) {
        valid = true;
        value = x;
        return *this;
    }

    bool valid;
    int  value;
};

T *p = new T[5]; // each element will be initialized to false/0 because T has a 
p[1] = 10;       // p[1] is now true/10

#include <vector>

...

    std::vector<int> x();
    x.resize(5);

std::map<int, int> x;
x[0] = 10;
x[2] = 123;
// indexes 0 and 2 are set, the rest do not exist.

#包括
...
std：：向量x（）；
x、 调整大小（5）；

---

现在，这将使您不再担心资源管理是一个婊子，而是专注于真正重要的事情（即处理XSE）。

我不会使用动态数组来完成这项工作，因为正确管理资源涉及到许多复杂问题。在我看来，您应该浏览一下

std:：vector

，这会使您的代码有点像这样：

struct T {
    T() : valid(false), value(0) {
    }

    bool valid;
    int  value;
};

T *p = new T[5]; // each element will be initialized to false/0 because T has a constructor.

struct T {
    T() : valid(false), value(0) {
    }

    T &operator=(int x) {
        valid = true;
        value = x;
        return *this;
    }

    bool valid;
    int  value;
};

T *p = new T[5]; // each element will be initialized to false/0 because T has a 
p[1] = 10;       // p[1] is now true/10

#include <vector>

...

    std::vector<int> x();
    x.resize(5);

std::map<int, int> x;
x[0] = 10;
x[2] = 123;
// indexes 0 and 2 are set, the rest do not exist.

#包括
...
std：：向量x（）；
x、 调整大小（5）；

现在，这将使您不再担心资源管理是一个婊子，而是专注于真正重要的事情（即处理XSE）

但是，问题是，当我用值填充它时，实际上可能会输入0。因此，这将导致混淆，即是什么告诉我们该值是否真的存在

对于“0”是否真的存在没有任何混淆。如果数组中有一个0，而您没有