C++ c++；字符串指针数组的初始化

我想初始化从构造函数中获取的

std:：string

指针数组。另外，我想对两个

int

数组执行相同的操作，但下面的代码无法编译：

class MyQuickInitArray
{
public:
    MyQuickInitArray(int size)
    {
        if(size <= 0)
        {
            throw new std::exception;
        }

        _size = size;
        _counter = 0;
        A = new std::string[size];
        B = new int[size];
        C = new int[size];
    }

    std::string& operator[](int j) {
        if(j > _size)
        {
            throw std::out_of_range("out of range");
        }

        if(((B[j]<0) || (B[j]>=_counter)) || (C[B[j]]!=j))
        {
            // A[j] points to junk
            _counter++;
            A[j] = new std::string;
            B[j] = _counter-1;
            C[_counter-1] = j;
            return A[j];
        }

        // the cell was instantiated before
        return A[j];
    }

    ~MyQuickInitArray(){};


private:
    std::string* A[];
    int B[];
    int C[];
    int _size;
    int _counter;
};

---

它们不是声明C++中静态数组的有效方式，数组大小需要在编译时知道。下面的代码不能在标准C++中编译，没有特殊的扩展。

std::string* A[];
int B[];
int C[];

如果你只是在玩指针游戏，那很好但是，您最好考虑使用

std:：vector

#include <vector>
std::vector<std::string> A;
std::vector<int> B;
std::vector<int> C;

#包括
std：：载体A；
std：：载体B；
std：：向量C；

我可以将您的代码改写为以下内容：

class MyQuickInitArray
{
public:
    MyQuickInitArray(int size)
      : A(size),
        B(size),
        C(size),
        size_(size),
        counter_(0)
    {     
    }

    std::string operator[](int j) const 
    {
        return A.at(j);
    }

private:
    std::vector<std::string> A;
    std::vector<int> B;
    std::vector<int> C;
    int size_;
    int counter_;
};

类MyQuickInitArray
{
公众：
MyQuickInitArray（整数大小）
：A（尺寸），
B（尺寸），
C（尺寸），
尺寸(尺寸),，
计数器（0）
{     
}
std:：字符串运算符[]（int j）常量
{
返回A.at（j）；
}
私人：
std：：载体A；
std：：载体B；
std：：向量C；
int-size_389;；
int计数器；
};
 > p>它们不是C++中声明静态数组的有效方式，数组大小需要在编译时知道。下面的代码不能在标准C++中编译，没有特殊的扩展。
std::string* A[];
int B[];
int C[];

如果你只是在玩指针游戏，那很好但是，您最好考虑使用
std:：vector

#include <vector>
std::vector<std::string> A;
std::vector<int> B;
std::vector<int> C;

#包括
std：：载体A；
std：：载体B；
std：：向量C；

我可以将您的代码改写为以下内容：

class MyQuickInitArray
{
public:
    MyQuickInitArray(int size)
      : A(size),
        B(size),
        C(size),
        size_(size),
        counter_(0)
    {     
    }

    std::string operator[](int j) const 
    {
        return A.at(j);
    }

private:
    std::vector<std::string> A;
    std::vector<int> B;
    std::vector<int> C;
    int size_;
    int counter_;
};

类MyQuickInitArray
{
公众：
MyQuickInitArray（整数大小）
：A（尺寸），
B（尺寸），
C（尺寸），
尺寸(尺寸),，
计数器（0）
{     
}
std:：字符串运算符[]（int j）常量
{
返回A.at（j）；
}
私人：
std：：载体A；
std：：载体B；
std：：向量C；
int-size_389;；
int计数器；
};
我想您应该使用
std:：vector
或
std:：vector
来代替数组成员。整个代码将更简单

但是如果您真的想使用阵列，那么您可以尝试（不是我推荐的）：

类MyQuickInitArray
{
公众：
MyQuickInitArray（int size）：_size（0），_计数器（0），A（nullptr），B（nullptr），C（nullptr）
{
如果（尺寸_尺寸）
{
抛出标准：：超出范围（“超出范围”）；
}
if（（B[j]=_计数器）| |（C[B[j]！=j））
{
//A[j]指向垃圾
_计数器++；
A[j]=新的std:：string；
B[j]=_计数器-1；
C[_计数器-1]=j；
返回*A[j]；
}
//之前已实例化该单元格
返回*A[j]；
}
~MyQuickInitArray（）{
对于（int j=0；j我想您应该使用
std:：vector
或
std:：vector
来代替数组成员。整个代码将更简单

但是如果您真的想使用阵列，那么您可以尝试（不是我推荐的）：

类MyQuickInitArray
{
公众：
MyQuickInitArray（int size）：_size（0），_计数器（0），A（nullptr），B（nullptr），C（nullptr）
{
如果（尺寸_尺寸）
{
抛出标准：：超出范围（“超出范围”）；
}
if（（B[j]=_计数器）| |（C[B[j]！=j））
{
//A[j]指向垃圾
_计数器++；
A[j]=新的std:：string；
B[j]=_计数器-1；
C[_计数器-1]=j；
返回*A[j]；
}
//之前已实例化该单元格
返回*A[j]；
}
~MyQuickInitArray（）{
for（int j=0；j“不编译”这还不够。另外，你应该使用
std:：vector
下面的代码没有编译，你也可以通过给出错误来帮助我们。认真地说，使用
std:：vector
。它可以去除80%的代码。你想要
A
和
B
的整数数组还是整数数组？@Mario整数数组“不编译"这还不够。另外，你应该使用
std:：vector
下面的代码没有编译，你也可以通过给出错误来帮助我们。认真地使用
std:：vector
。它可以去除80%的代码。你想要
A
和
B
的整数数组还是整数数组？@Mario整数数组-1:W你到底会给我什么建议呢？
std:：string*A；
这显然是个糟糕的建议。@AlokSave我在回答中确实问过他是否在练习指针。我还建议用向量表示A，B，C@AlokSave我删除了与
std:：string*A；
：）相关的任何内容+1：这是正确的答案。但我很好奇——如果size@qPCR4virvector以大小0开始，问题实际上是大小<0-1:你到底为什么要建议
std:：string*A；
这显然是个糟糕的建议。@AlokSave我在回答中问过他是否在练习指针。我还建议用vector来表示A，B，C@AlokSave我是雷姆我喜欢任何与
std:：string*A；
：）+1:这是正确的答案。但我很好奇，如果size@qPCR4vir向量以大小0开始，关注点实际上是大小<0