Passing pointer to function as an output parameter - c++

Question

I am using 'pBuff' as pointer and put a char array in function 'myfunc'.
So, In main function, I should receive it in aBuff.
But it is not working.. what is wrong here ??
#include <stdio.h>
void myfunc(void *pBuff, int &i);
int main()
{
int len;
char aBuff[2]={0};
printf("Hello World");
myfunc(aBuff,len);
printf("aBuff %s", aBuff);
return 0;
}
myfunc(void *pBuff, int &i){
char a[2] = {'a', 'b'};
i = 5;
pBuff = &a;
}
char a[] should come as output parameter in main function

Answer 1

You are passing a pointer to your function, inside your function you assign the address of the temporary variable a to the pBuff variable. The original aBuff variable is unaffected.
As we are using c++ a much simpler solution using strings would be:
#include <iostream>
void myfunc(std::string& pBuff, int &i);
int main()
{
int len;
std::string aBuff;
std::cout << "Hello World";
myfunc(aBuff,len);
std::cout << "aBuff " << aBuff;
return 0;
}
void myfunc(std::string& pBuff, int &i){
pBuff = "ab";
i = 5;
}
If you really must use raw character arrays then this would be one way to implement it (note the removal of the void*, no reason to use it here):
myfunc(char *pBuff, int &i){
strcpy(pBuff, "ab");
i = 5;
}
If you need to store 2 characters in your aBuff array it needs to be 3 characters long not 2 as you need to leave space for the null terminator otherwise printf and other string functions will not work correctly.

Answer 2

If you want to return an array you have several possible solutions:
Pass a pointer (type*) to the function and copy the data unsing e.g. memcpy. You should also pass the size of the destination array and make sure you don't copy too much data.
Pass a reference to the pointer (type *&) and assign to the pointer in the function
Pass the address of the pointer (type**) and assign the address to the dereferenced pointer.
You must not return the address of a local variable with automatic storage. If you want to return a (which is a pointer to the first element) from the function it must be either static or dynamically allocated using e.g. malloc.
Which solution to choose depends on your needs:
Examples for 3 variants:
#include <stdio.h>
#include <memory.h>
void myfunc(char **pBuff, int &i);
void myfunc2(char *&pBuff, int &i);
void myfunc1(char *pBuff, size_t bufsize, int &i);
int main()
{
int len;
char aBuff[3]={0}; // increased size for NUL termination
char *ptr = aBuff;
printf("Hello World");
myfunc(&ptr,len);
printf("ptr %s", ptr);
printf("\n");
myfunc2(ptr,len);
printf("ptr %s", ptr);
printf("\n");
myfunc1(aBuff, sizeof aBuff,len);
printf("aBuff %s", aBuff);
return 0;
}
void myfunc1(char *pBuff, size_t bufsize, int &i){
char a[3] = {'c', 'd', '\0'}; /* added '\0' to allow using it as a string */
i = 5;
// actually the minimum of bufsize and sizeof(a) should be used
memcpy(pBuff, a, bufsize);
}
void myfunc(char **pBuff, int &i){
static char a[3] = {'a', 'b', '\0'}; // added '\0' to allow using it as a string
i = 5;
*pBuff = a;
}
void myfunc2(char *&pBuff, int &i){
static char a[] = "xyz";
i = 5;
pBuff = a;
}