14

我通过引用传递一个 char 数组，但是当我从函数返回并打印数组时，它什么也不显示。我究竟做错了什么？

#include <iostream>

using namespace std;

void func(char []);
int main()
{
   char a[100];
   func(a);

   cout << a<<endl;
   return 0;
}

void func(char *array)
{
   array="Inserting data in array a";
   cout << array<<endl;
}

问候

4

9 回答 9

10

您可能可以做的是：

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

}

这意味着：通过引用 ( ) 传递一个包含[..]10 ( [10]) 个字符 ( )的数组 ( )。char(& ..)

于 2012-10-20T11:20:07.833 回答
9

你没有通过引用传递数组（你也不应该，这对你没有好处）。您正在传递一个指向其第一个元素的指针。然后，您重新分配该指针以指向函数内的其他内容。这对阵列没有影响。如果要更改数组的内容，则需要将数据复制到指针指向的位置。您可以使用 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;
}
于 2012-10-20T11:07:49.320 回答
5

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

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

在函数内部，你使用这个参数作为一个简单的指针。如果修改了值，这些更改在外部可见。

于 2012-10-20T11:09:41.203 回答
2

尝试以下操作：

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”，您只更改副本的地址，而不是主函数中数组的地址。

这个例子实际上可以工作，因为这样你在函数中没有指针的副本：

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;
}
于 2012-10-20T11:47:58.783 回答
2

我使用了上面的答案，但我必须扩展它，所以我可以打印出数组的实际大小，如下所示：

template<size_t n> void foo(char (&array)[n])
{
    // ...
    std::cout << "array size: " << n << std::endl;
    // ...
}
于 2018-01-11T09:30:53.953 回答
0

您正在传递一个指向数组 ( func (char* array)) 的指针，然后在函数内部将指针的值更改为指向静态字符串。

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

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

或者：

strcpy(array, "data");

最好使用std::vector<>orstd::string代替。

于 2012-10-20T11:10:33.793 回答
0

对本机数组的引用是非常强大的 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++ 来说是相当简单和独特的。

于 2019-11-09T11:46:27.280 回答
0

我知道这篇文章有点老了，但我最近遇到了一种将 char 数组作为参考传递的风格，并在你的示例中实现了它。

我不知道为什么在传递 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 作为参数发送是低效的。这就是为什么我们会通过引用来代替

于 2021-03-25T02:09:32.243 回答
-1

错误第一行iostream.h ...其次，您没有将任何元素插入数组...并且您在函数中传递 a ，您必须将数组的地址传递给该函数，但在此之前将代码重写为你的数组里有东西

于 2012-10-20T11:46:29.950 回答