通过引用传递字符阵列

您可以做的是：

void func( char (& array)[10] ) {
}

根据螺旋规则，将其转换为：参考（&）为长度为10（[10]）字符（char）的数组。

您不是通过参考传递数组（您也不应在这里对您不好。您正在将指针转到其第一个元素。然后，您重新分配该指针，以指向功能中的其他内容。这对数组没有影响。如果要更改数组的内容，则需要将数据复制到指针指向的位置。您可以使用strcpy或类似：

strcpy(array, "Inserting data in array a");

作为附带评论，但非常重要。我们不再需要在C 中处理类似的事情。这就是您在C中做事的方式。这就是我们在C 中做事的方式：

#include <string>
#include <iostream>
void func(std::string & str)
{
    str = "Inserting data into the string";
    std::cout << str << std::endl;
}
int main()
{
    std::string a;
    func(a);
    std::cout << a << std::endl;
}

您可以通过参考传递指针。为此，您需要使用以下语法：

void func(char *&array)
{
    // ....
}

在功能中，您将此参数用作常规指针。如果该指针指向的值已修改，则这些更改将在外部看到。

我使用了上面的答案，但我必须扩展它，因此我可以像这样打印出数组的实际大小：

template<size_t n> void foo(char (&array)[n])
{
    // ...
    std::cout << "array size: " << n << std::endl;
    // ...
}

尝试以下内容：

void function(char* MyArray)
{
    MyArray = "Hello World";
    std::cout << "Address of MyArray inside function: " << (void*)MyArray << std::endl;
}
int main()
{
    char MyArray[10];
    std::cout << "Address of MyArray outside function: " << (void*)MyArray << std::endl;
    function(MyArray);
    std::cout << "Address of MyArray outside function: " << (void*)MyArray << std::endl;
    std::cin.get();
    return 0;
}

使用此功能，您会看到指向数组的指针只是函数中的一个副本。通过分配" Hello World"，您只会更改副本的话词，而不会更改主函数中数组的adress。

这个示例实际上会起作用，因为这样您就没有函数中的指针的副本：

void function(char** MyArray)
{
    *MyArray = "Hello World";
    std::cout << "Address of MyArray inside function: " << (void*)*MyArray << std::endl;
}
int main()
{
    char* MyArray = 0;
    std::cout << "Address of MyArray outside function: " << (void*)MyArray << std::endl;
    function(&MyArray);
    std::cout << "Address of MyArray outside function: " << (void*)MyArray << std::endl;
    std::cin.get();
    return 0;
}

但这仍然是不好的风格。使用字符数组时，您应该做这样的事情：

void function(char* MyArray)
{
    strcpy(MyArray, "Hello World");
    std::cout << "Address of MyArray inside function: " << (void*)MyArray << std::endl;
}
int main()
{
    char* MyArray = 0;
    MyArray = new char[15];
    std::cout << "Address of MyArray outside function: " << (void*)MyArray << std::endl;
    function(MyArray);
    std::cout << "Address of MyArray outside function: " << (void*)MyArray << std::endl;
    delete [] MyArray;
    std::cin.get();
    return 0;
 } 

但是，正如其他人提到的，我将使用std :: string并通过引用传递，而不是使用字符数组。因为与std :: string相比，字符数组不安全。这样：

void function(std::string& MyString)
{
    MyString = "Hello World";
}
int main()
{
    std::string MyString;
    function(MyString);
    std::cin.get();
    return 0;
}

您将指针传递到数组（func (char* array)），然后在功能内部更改指针的值以指向静态字符串。

您要么需要通过strcpy()将新数据复制到数组中，要么通过参考将指针传递给数组：

void func(char*& array); // reference to pointer

或：

strcpy(array, "data");

最好使用std::vector<>或std::string。

引用本机数组是非常强大的C 武器之一。加上模板。这是一个，也许是无聊但仍然很简单的例子。

// set all element of a given native array reference 
// to the same value
// return the reference to the same array
    template<typename T, size_t N, typename array_type = T[N] >
    inline
        array_type&  /* return reference to T[N] */
        all_val 
         (  T(&arf)[N],  /* arg reference to T[N] */
            T val   )
    {
        // range for() works on native arrays
        // begin(arf) / end(arf)
        // work as expected
        for (auto & elem : arf) {
            elem = val ;
        }
        // array can not be returned by value
        // but this is allowed in standard C++
        // return type is native array reference
        return arf;
    }

使用上述时，应该思考并保存返回的类型作为本机数组参考。

        using charray_type = char[0xF];
        charray_type charray;
        // decaying to pointer to T*
        // you do not want this
        auto pointer_to_char = all_val(charray, '*');
        // you do want this
        // preserving the ref to array
        charray_type& charray_ref = all_val(charray, '*');
        // normal native arr usage
        charray_ref[0] = '*';
        assert(charray[0] == charray_ref[0]);

我认为这是标准C 独有的简单且独有的。

我知道这篇文章有点旧

我不知道为什么在传递char数组作为参考时，您使用[0]作为数组索引，但此代码有效。

我花了很多时间在网上看如何做这件事，所以也许它可以帮助某人

#include <iostream>
using namespace std; 
void  func(char arr[3]);
int main()
{
  char a[3];
  a[0] ='a'; 
  a[1] ='b';
  a[2] ='c';
 //passing the char array as a refrence
 func(&a[0]);
 cout<< "checking the values outside of the func"<<endl;
 cout << a<<endl;
 return 0;
}
void func(char arr[3])
{
   cout<<"Inserting data in array a in the function " <<endl;
   cout << &arr[0]<<endl;
}

传递对象作为参考的主要思想是没有对象的副本，因为这可能会用尽内存资源。因此，在char数组的情况下，您可能有很大的数组，因此将整个char阵列objet作为一个参数效率低下。这就是为什么我们将通过参考而改为

错误第一行 iostream.h ...其次，您没有将任何元素插入数组...并且您在功能中传递A，您必须将数组的地址传递到该函数中，但是在重写代码之前，您的数组中有一些内容