Do pointers to string literals remain valid after a function returns?

by

On storage duration:

2.13.4
Ordinary string literals and UTF-8 string literals are also referred to as narrow string literals. A narrow
string literal has type “array of n const char”, where n is the size of the string as defined below, and has
static storage duration

read in conjunction with 3.7.1

3.7.1.

All objects which do not have dynamic storage duration, do not have thread storage duration, and are
not local have static storage duration. The storage for these objects shall last for the duration of the
program (3.6.2, 3.6.3).

On type:

Annex C

Subclause 2.13.4:

Change: String literals made const
The type of a string literal is changed from “array of char ” to “array of const char.” The type of a
char16_t string literal is changed from “array of some-integer-type ” to “array of const char16_t.” The
type of a char32_t string literal is changed from “array of some-integer-type ” to “array of const char32_-
t.” The type of a wide string literal is changed from “array of wchar_t ” to “array of const wchar_t.”

Rationale: This avoids calling an inappropriate overloaded function, which might expect to be able to
modify its argument.

Effect on original feature: Change to semantics of well-defined feature.
Difficulty of converting: Simple syntactic transformation, because string literals can be converted to
char*; (4.2). The most common cases are handled by a new but deprecated standard conversion:
char* p = “abc”; // valid in C, deprecated in C++
char* q = expr ? “abc” : “de”; // valid in C, invalid in C++

How widely used: Programs that have a legitimate reason to treat string literals as pointers to potentially
modifiable memory are probably rare.

Dynamically allocated (the word ‘heap’ is never used in context of an area of memory AFAIK in the standard) memory requires a function call that can happen as early as main much after the static memory is allocated.

More Related Contents:

  1. C/C++ int[] vs int* (pointers vs. array notation). What is the difference?
  2. Is it unspecified behavior to compare pointers to different arrays for equality?
  3. Is it legal/well-defined C++ to call a non-static method that doesn’t access members through a null pointer?
  4. Dangling Pointers after Destructor is called
  5. Why do i have a random result on this template?
  6. Weird behavior with OOP and string pointers
  7. Regular cast vs. static_cast vs. dynamic_cast [duplicate]
  8. How do I use arrays in C++?
  9. What is the difference between const int*, const int * const, and int const *?
  10. Should I use static_cast or reinterpret_cast when casting a void* to whatever
  11. One-dimensional access to a multidimensional array: is it well-defined behaviour?
  12. What’s the difference between __PRETTY_FUNCTION__, __FUNCTION__, __func__?
  13. difference between a pointer and reference parameter?
  14. Returning arrays from a function in c++
  15. Pointers in c++ after delete
  16. Is there any reason to check for a NULL pointer before deleting?
  17. Returning a pointer of a local variable C++
  18. Can I use if (pointer) instead of if (pointer != NULL)?
  19. Is storing an invalid pointer automatically undefined behavior?
  20. How to know if a pointer points to the heap or the stack?
  21. Why does std::cout convert volatile pointers to bool?
  22. Cast pointer to member function to normal pointer
  23. A pointer to 2d array
  24. What are near, far and huge pointers?
  25. Is auto_ptr deprecated?
  26. C++ Access derived class member from base class pointer
  27. Declaring type of pointers?
  28. How to overload operator==() for a pointer to the class?
  29. What does ‘dereferencing’ a pointer mean in C/C++?
  30. int *array = new int[n]; what is this function actually doing?

Leave a Comment