Passing char array by reference

Question

I am passing a char array by reference but when I return from function and print the array, it displays nothing. What am I doing wrong?

#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;
}

Regards

Answer 1

What you can probably do is:

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

}

According to the Spiral Rule, that is translated to: a reference (&) to an array of length 10 ([10]) characters (char).

Answer 2

You're not passing the array by reference (nor should you, it will do you no good here). You are passing a pointer to its first element. You then reassign that pointer to point to something else inside the function. This has no effect on the array. If you want to change the contents of the array, then you need to copy data to the place that the pointer points to. You can use strcpy or similar for that:

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

As a side comment, but a very important one. We don't need to deal with things like this in C++ anymore. That's how you do things in C. Here's how we do things in 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;
}

Answer 3

You can pass a pointer by reference. To do this you need to use the following syntax:

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

Inside the function you use this parameter as a regular pointer. If the value that this pointer is pointing at is modified, these changes will be visible outside.

Answer 4

I used the answers above but I had to extend it, so I could print out the array's actual size like so:

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

Answer 5

Try the following:

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;
}

With this you will see that the pointer to your array is only a copy inside the function. With assigning "Hello World" you only change the adress of the copy but not the adress of your array in the main function.

This example would actually work because this way you dont have copy of your pointer within the function:

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;
}

But this is still bad style. When working with character arrays you should do something like this:

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;
 } 

But as others mentioned I would use std::string and pass it by reference also instead of using character arrays. Because character arrays are unsafe compared to std::string. Like this:

void function(std::string& MyString)
{
    MyString = "Hello World";
}

int main()
{
    std::string MyString;
    function(MyString);

    std::cin.get();
    return 0;
}

Answer 6

You are passing a pointer to an array (func (char* array)) and then inside the function you are changing the pointer's value to point to the static string.

You either need to copy the new data into the array by means of strcpy() or pass the pointer to the array by reference:

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

Or:

strcpy(array, "data");

Better yet use std::vector<> or std::string instead.

Answer 7

Reference to native array is one of the very powerful C++ weapons. Plus templates. Here is one, perhaps non trivial but still simple example.

// 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;
    }

When using the above, one should think and preserve returned type as native array reference.

        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]);

I think this is rather simple and unique to standard C++.

Answer 8

I know this post is kind of old but I recently came across a style of passing char array as a reference and implemented it in your example ..

I have no Idea why when passing a char array as a reference you use [0] as the array index but this code works .

I spend allot of time looking around the web on how to do this so maybe it helps someone

#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;
}

The main idea behind passing an object as a reference is to not have a copy of the object as this could use up memory resources . So in the case of char array you might have very large array so it would be inefficient to send the whole char array objet as an argument . This is why we would pass by a reference instead

Answer 9

error first line iostream.h ... and secondly you are not inserting any element into array...and you are passing a in your function, you have to pass address of your array into that function, but before that rewrite the code to have something in your array