Is it valid (defined behavior) to access a string literal simultaneously with multiple threads? Given a function like this:

```
const char* give()
{
  return "Hello, World!";
}

```

Would it be save to call the function and dereference the pointer simultaneously?

Edit: Many answers. Will accept the first one who can show me the section out of the standard.
['https://Stackoverflow.com/questions/9533392', 'https://Stackoverflow.com', 'https://Stackoverflow.com/users/941699/']
According to the standard:

> 
> C++11 1.10/3: The value of an object visible to a thread T at a particular point is the initial value of the object, a value assigned to the object by T, or a value assigned to the object by another thread, according to the rules below.
> 
> 
> 

A string literal, like any other constant object, cannot legally be assigned to; it has static storage duration, and so is initialised before the program starts; therefore, all threads will see its initial value at all times.

Older standards had nothing to say about threads; so if your compiler doesn't support the C++11 threading model then you'll have to consult its documentation for any thread-safety guarantees. However, it's hard to imagine any implementation under which access to immutable objects were not thread-safe.
String literals are (conceptually) stored in read only memory and initialised on loading (rather than at runtime). It's therefore safe to access them from multiple threads at any time.

Note that more complex structures might not be initialised at load time, and so multiple thread access might have the possibility of issues immediately after the creation of the object.

But string literals are completely safe.