Since I can’t return a local variable, what’s the best way to return a string from a C or C++ function?

by

You’re absolutely right. Your c array in the second example is being allocated on the stack, and thus the memory will get reused immediately following. In particular, if you had code like

 printf("%s\n",greet());

you’d get weird results, because the call to printf would have reused some of the space of your array.

The solution is to allocate the memory somewhere else. For expample:

char c[] = "Hello";

char * greet() {
    return c;
}

Would work. Another choice would be to allocate it statically in scope:

char * greet() {
    static char c[] = "Hello";
    return c;
}

because static memory is allocated separately from the stack in data space.

Your third choice is to allocate it on the heap via malloc:

char * greet() {
   char * c = (char *) malloc(strlen("Hello")+1);  /* +1 for the null */
   strcpy(c, "Hello");
   return c;
}

but now you have to make sure that memory is freed somehow, or else you have a memory leak.

Update

One of those things that seems more confusing than I expect is what exactly a “memory leak” is. A leak is when you allocate memory dynamically, but lose the address so it can’t be freed. None of these examples necessarily has a leak, but only the third one even potentially has a leak, because it’s the only one that allocates memory dynamically. So, assuming the third implementation, you could write this code:

{
    /* stuff happens */
    printf("%s\n", greet());
}

This has a leak; the pointer to the malloc’ed memory is returned, the printf uses it, and then it’s lost; you can’t free it any longer. On the other hand,

{
    char * cp ;
    /* stuff happens */
    cp = greet();
    printf("%s\n", cp);
    free(cp);
}

doesn’t leak, because the pointer is saved in an auto variable cp long enough to call free() on it. Now, even though cp disappears as soon as execution passes he end brace, since free has been called, the memory is reclaimed and didn’t leak.

More Related Contents:

  1. Why is sizeof giving incorrect number of bytes in C++?
  2. When and why will a compiler initialise memory to 0xCD, 0xDD, etc. on malloc/free/new/delete?
  3. Is the sizeof(some pointer) always equal to four?
  4. Which is faster: Stack allocation or Heap allocation
  5. Why aren’t pointers initialized with NULL by default?
  6. Why is address zero used for the null pointer?
  7. What is the purpose of std::launder?
  8. Memory management in Qt?
  9. When to use bit-fields in C?
  10. stringstream, string, and char* conversion confusion
  11. General guidelines to avoid memory leaks in C++ [closed]
  12. Do class/struct members always get created in memory in the order they were declared?
  13. Measuring memory bandwidth from the dot product of two arrays
  14. C++11 lambda implementation and memory model
  15. What is the behavior of “delete” with stack objects? [duplicate]
  16. g++ variable size array no warning?
  17. How to solve Memory Fragmentation
  18. Can I Allocate a specific memory address using pointers in c++?
  19. What is a jump table?
  20. Is std::vector memory freed upon a clear?
  21. How do I call the original “operator new” if I have overloaded it?
  22. C++ string literal data type storage
  23. Dereferencing deleted pointers always result in an Access Violation?
  24. What does “Memory allocated at compile time” really mean?
  25. Is Python faster and lighter than C++? [closed]
  26. How is its lifetime of a return value extended to the scope of the calling function when it is bound to a const reference in the calling function?
  27. C++11: Replace all non-owning raw pointers with std::shared_ptr()?
  28. C++ virtual function table memory cost
  29. How to ignore false positive memory leaks from _CrtDumpMemoryLeaks?
  30. How to get the starting/base address of a process in C++?

Leave a Comment