C++ 数组作为参数

我创建了一个数组：

CString* pstrArray = new CString[nMySize];

现在，我如何将其传递给要填充的函数？实际参数是什么

void FillThisArray(what goes here?)
{
}

---

您不能这样做吗？

您需要将指针传递到第一个元素，以及可用元素的数量：

void FillThisArray(CString* strings, size_t num)
{
}

---

您应该使用容器类：

如果您不想这样做（我看不出任何可能的原因，但无论如何）：

void FillThisArray（CString*字符串，大小\u t num）
{
//范例
对于（size_t s=0；s，必须将动态分配的数组作为指向其第一个元素的指针传递。有两种语法，它们都是等效的：

void FillThisArray(CString* strArray)
{
}

或

您可以将strArray参数用作函数内的数组。请注意，指针不包含有关数组实际大小的信息，因此如果大小不全局可用，则应将大小作为第二个参数传递。hth

CString*pstrArray=NULL；pstrArray=new-CString[nMySize]

为简单起见：

CString* pstrArray = new CString[nMySize];

现在如何将其传递给要填充的函数？实际参数是什么？

空填充此数组（？？？？{}

最明显的界面是：

void FillThisArray(CString* pstrArray, size_t n)

退一步：


请注意，nMySize default构造的
CString
s的所有内存都将由该新语句分配
您应该考虑使用<代码> STD:：向量< /代码>

std:：vector
因为：

超出范围时自动删除所有字符串的内存
默认情况下，当使用例如
push_back（）
添加字符串时，内存使用量将逐渐增加，并且在这种情况下，内存使用量可以超过初始大小，而无需您进行任何特殊工作
如果确实需要，可以在构造
向量时主动为nMySize字符串保留空间，和/或创建它们


std:：string
因为：

是C++标准定义的可移植字符串类型，并减少了对依赖项
的锁定
也就是说，在某些情况下避免这种做法可能不切实际或效率低下


如果你不能使用一个标准容器类，有一个很好的理由，考虑使用迭代器风格的方法。这将省去你担心数组在你的函数中有多大：

void FillThisArray(CString* begin, CString* end)
{
    for (CString* iter = begin; iter != end; ++iter)
    {
        *iter = "Some text";
    }
}

int main()
{
    CString* pstrArray = new CString[nMySize];
    FillThisArray(&pstrArray[0], &pstrArray[nMySize]);

    for (int i = 0; i < nMySize; ++i)
    {
        assert(pstrArray[i] == "Some_text");
    }

    delete[] pstrArray;
}

void FillThisArray（CString*begin，CString*end）
{
用于（CString*iter=begin；iter！=end；++iter）
{
*iter=“一些文本”；
}
}
int main（）
{
CString*pstrArray=新CString[nMySize]；
填充此数组（&pstrArray[0]，&pstrArray[nMySize]）；
对于（int i=0；i

您甚至可以对函数进行模板化，使其不与pstrArray的（有问题的）实现相关联：

template <typename T>
void FillThisArray(T begin, T end)
{
    for (T iter = begin; iter != end; ++iter)
    {
        *iter = "Some text";
    }
}

int main()
{
    {
        CString* pstrArray = new CString[nMySize];
        FillThisArray(&pstrArray[0], &pstrArray[nMySize]);

        for (int i = 0; i < nMySize; ++i)
        {
            assert(pstrArray[i] == "Some text");
        }

        delete[] pstrArray;
    }
    {
        std::vector<std::string> better(nMySize);
        FillThisArray(better.begin(), better.end());
        for (int i = 0; i < nMySize; ++i)
        {
            assert(better[i] == "Some text");
        }
    }
}

模板
无效填充此数组（T开始，T结束）
{
for（iter=begin；iter！=end；++iter）
{
*iter=“一些文本”；
}
}
int main（）
{
{
CString*pstrArray=新CString[nMySize]；
填充此数组（&pstrArray[0]，&pstrArray[nMySize]）；
对于（int i=0；i
在什么方面这是一个C问题？这看起来不像是有效的C…或者最好还是使用
std:：vector
@Naveen：我同意如果OP使用std:：stringNo，OP应该如何知道有效项目的数量？+1表示漂亮的“C++-y”迭代器风格-虽然在这里没有实际的好处，但它不鼓励假设函数必须填充整个数组。模板是一个不错的主意，尽管如果分配到元素中的数据类型太具体，那么如果生成器没有进一步的灵活性，模板就变得不那么有用。“这会让你不用担心数组在你的函数中有多大”-这不是真的，因为传递
&array[n]
与传递
n
显然节省不了多少；-P.不必传递任何一个都是节省。谢谢Tony。
&array[n]
，我的意思是这将从函数的实现中删除大小。迭代器还有许多我没有提到的其他好处（考虑颠倒顺序、选择性谓词等）。
CString* pstrArray = new CString[nMySize];

void FillThisArray(CString* pstrArray, size_t n)

void FillThisArray(CString* begin, CString* end)
{
    for (CString* iter = begin; iter != end; ++iter)
    {
        *iter = "Some text";
    }
}

int main()
{
    CString* pstrArray = new CString[nMySize];
    FillThisArray(&pstrArray[0], &pstrArray[nMySize]);

    for (int i = 0; i < nMySize; ++i)
    {
        assert(pstrArray[i] == "Some_text");
    }

    delete[] pstrArray;
}

template <typename T>
void FillThisArray(T begin, T end)
{
    for (T iter = begin; iter != end; ++iter)
    {
        *iter = "Some text";
    }
}

int main()
{
    {
        CString* pstrArray = new CString[nMySize];
        FillThisArray(&pstrArray[0], &pstrArray[nMySize]);

        for (int i = 0; i < nMySize; ++i)
        {
            assert(pstrArray[i] == "Some text");
        }

        delete[] pstrArray;
    }
    {
        std::vector<std::string> better(nMySize);
        FillThisArray(better.begin(), better.end());
        for (int i = 0; i < nMySize; ++i)
        {
            assert(better[i] == "Some text");
        }
    }
}