Does std::thread in another thread crash if its parameters are deleted?

Question

I read a lot & I'm still unsure if I understood it or not (Im a woodworker).

Let's suppose that I have a function:

void class_test::example_1(int a, int b, char c)
{
//do stuff
int v;
int k;
char z;
if(condition)
    {
     std::thread thread_in_example (&class_test::example_1, & object, v ,k ,z);
     th.detach();
    }
}

Now if I call it:

std::thread example (&class_test::example_1, &object, a, b, c);
example.detach();

Question: What happen to thread_in_example when example complete & "detele" himself? is thread_in_example going to lost access to its parameters?

I thought that std::thread was making a copy of the elements unless they are given by &reference but on http://en.cppreference.com/w/cpp/thread/thread I can't really understand this part (du to my lack of knowledge in programming/english/computer science's semantics):

std::thread objects may also be in the state that does not represent any thread (after default construction, move from, detach, or join), and a thread of execution may be not associated with any thread objects (after detach).

and this one too:

No two std::thread objects may represent the same thread of execution; std::thread is not CopyConstructible or CopyAssignable, although it is MoveConstructible and MoveAssignable.

So I've doubts on how it really works.

Answer 1

From this std::thread::detach reference:

Separates the thread of execution from the thread object, allowing execution to continue independently. Any allocated resources will be freed once the thread exits.

_{[Emphasis mine]}

Among those "allocated resources" will be the arguments, which means you can still safely use the arguments in the detached thread.

Unless you of course the arguments are references or pointers to objects that are destructed independently of the detached thread or the thread that created the detached thread.