char*

[cs8]

Just testing and need to know how to make this code work without using dynamic mem allocation for b?.

char* rchar()
{
	char b[100];
	strcpy(b, "Hello World\n");
	return (char*&)b;
}
int main(int argc, char* argv[])
{
	char *s = rchar();
	printf("%s",s);
	return 0;
}

[ZuK]

 char* rchar()
{
	static char b[100];
	strcpy(b, "Hello World\n");
	return b;
}

Kurt

[klamath23]

Just testing and need to know how to make this code work without using dynamic mem allocation for b?.

char* rchar()
{
	char b[100];
	strcpy(b, "Hello World\n");
	return (char*&)b;
}
int main(int argc, char* argv[])
{
	char *s = rchar();
	printf("%s",s);
	return 0;
}

hello cs8,
this is how one way you can work without error.

#include<cstdio>
#include<cstring>

char* rchar()
{
	char *b = "hello world";
        return b;
}
int main(int argc, char* argv[])
{
	char *s = rchar();
	printf("%s",s);
	return 0;
}

OUTPUT:
hello world

[cs8]

How about if return is int*?.

int* f()
{
	int i[4];
	i[0] = 1;
	i[1] = 2;
	i[2] = 3;
	i[3] = 4;

	int* u = i;
	return u;
}
int main(void)
{
	int* g = f();
	printf("%d\n", *g++);
	printf("%d\n", *g++);
	printf("%d\n", *g++);	
	printf("%d\n", *g++);

	return 0;
}

[sunnypalsingh]

char* rchar()
{
	char b[100];
	strcpy(b, "Hello World\n");
	return (char*&)b;
}

When a function returns, its automatic, local variables are discarded, so the returned pointer in this case is invalid (it points to an array that no longer exists).

char* rchar()
{
	static char b[100];
	strcpy(b, "Hello World\n");
	return b;
}

This fix is imperfect, since a function using static data is not reentrant.

There can be many alternate ways like

• Returning dynamically allocated data. In this case, it will be the caller's responsibility to free the storage.

• Using caller-provided storage. This method is recommended, although the interface needs to be modified.

• Combination of above two: if the caller passes a null pointer, the routine returns a dynamically-allocated pointer.

• Combination of Zuk's method & caller-provided storage :if the caller passes a null pointer, the routine returns a pointer to static data(non-reentrant).

[cs8]

what's right way for this?:

int* f()
{
	int i[4];
	i[0] = 1;
	i[1] = 2;
	i[2] = 3;
	i[3] = 4;

	int* u = i;
	return u;
}
int main(void)
{
	int* g = f();
	printf("%d\n", *g++);
	printf("%d\n", *g++);
	printf("%d\n", *g++);	
	printf("%d\n", *g++);

	return 0;
}

[Paul McKenzie]

hello cs8,
this is how one way you can work without error.
[code]

There is a big difference between what the OP was trying to do, and what you're showing. That difference is that the OP declared an array of char, and attempted to return it (which of course wouldn't work). What you declared is a string-literal. This is different than an array of char, since you cannot modify a string-literal. If the OP later on wanted to modify the array, returning a string-literal is not recommended.

The easiest thing to do if this is C++ is just return a std::string (there seems to be that a lot of posters lately are struggling to figure out how to return char *).

Regards,

Paul McKenzie

[Paul McKenzie]

what's right way for this?:

You cannot return a pointer to a local variable.

Regards,

Paul McKenzie

[Paul McKenzie]

what's right way for this?:

#include <vector>
#include <cstdio>

std::vector<int> f()
{
   std::vector<int> i(4);
   i[0] = 1;
   i[1] = 2;
   i[2] = 3;
   i[3] = 4;
   return i;
}

int main()
{
	std::vector<int> g = f();
        int *pg = &g[0];
	printf("%d\n", *pg++);
	printf("%d\n", *pg++);
	printf("%d\n", *pg++);	
	printf("%d\n", *pg++);
	return 0;
}

Another way.

#include <cstdio>

void f(int *i)
{
   i[0] = 1;
   i[1] = 2;
   i[2] = 3;
   i[3] = 4;
}

int main()
{
   int g[4];
   f(g);
   printf("%d\n", *g++);
   printf("%d\n", *g++);
   printf("%d\n", *g++);	
   printf("%d\n", *g++);
   return 0;
}

Regards,

Paul McKenzie

[NMTop40]

You are assuming, Paul, that this is C++ but the OP has posted code that is pure C so let's assume that it is pure C because otherwise there is no reason not to return string. (Let's ignore "embedded C++" for now). Note that it may well be a C++ library with a C interface.

There is another option which is to return a struct that has an array of chars big enough to hold this particular string.

struct char_array_32
{
  char data[32];
};

struct char_array_32 rchar()
{
   struct_char_array output;
   strcpy( output.data, "Hello world!" );
   return output;
}

Of course you may well define different varieties of this struct but it will allow you to get away with not having to make runtime allocations as long as you can be certain to return a struct big enough.

There is a preferable way, which is commonly used in C interfaces and that is to get the user to provide the write buffer and a maximum write size.

We will also return the size of the buffer that we have written or what we wanted to write.

size_t rchar( char * buffer, size_t insize )
{
   strncpy( buffer, "Hello world!", insize );
   return 13; // in reality you would return variable data 
}

Note this technique can at times be very useful in C++ too.

[treuss]

What you declared is a string-literal. This is different than an array of char, since you cannot modify a string-literal.

This is a bit off-topic, but as Paul has mentioned it, something I have been wondering for a long time:

How come it is legal to assign string literals to (non-const) char*? I am not even getting a compiler warning for the following:

#include <iostream>

int main() {
  char * c = "Hello World!";
  std::cout << c << std::endl;
}

Is c now really a char * or a const char * in disguise?

[sunnypalsingh]

This is a bit off-topic, but as Paul has mentioned it, something I have been wondering for a long time:

How come it is legal to assign string literals to (non-const) char*? I am not even getting a compiler warning for the following:

#include <iostream>

int main() {
  char * c = "Hello World!";
  std::cout << c << std::endl;
}

Is c now really a char * or a const char * in disguise?

Because of historical reasons a string literal can be assigned to a char*. This is allowed because in previous definitions of C and C++ , the type of a string literal was char*. Allowing the assignment of a string literal to a char* ensures that millions of lines of C and C++ remain valid.

[Zaccheus]

Another way.

#include <cstdio>

void f(int *i)
{
   i[0] = 1;
   i[1] = 2;
   i[2] = 3;
   i[3] = 4;
}

int main()
{
   int g[4];
   f(g);
   printf("%d\n", *g++);
   printf("%d\n", *g++);
   printf("%d\n", *g++);	
   printf("%d\n", *g++);
   return 0;
}

That's what I was going to suggest as well, but I would pass to f the number of elements which the array contains.

Something like:

void f(int *i, size_t n)
{
    if(n >= 4)
    {
        i[0] = 1;
        i[1] = 2;
        i[2] = 3;
        i[3] = 4;
    }
}

Of course you would then also need some kind of error reporting if n does not have an appropriet value.