Pass a point into a thread and have it modified - c++

Question

I need to keep reference of an object passed into a thread. The way the environment is setup I must keep application specific drawing in the same thread it was initiated. So I tuck away app init code in a thread and then get a reference to a custom component I'm interested in.
This isn't working. The app loads and shows up fine but the pointer to the app in the main thread is always null. Even if I use std::shared_ptr or std::ref. Doesn't seem to matter what I do, the pointer is always null.
#include <thread>
#include <iostream>
class SomeClass {
public:
int value;
SomeClass() { value = 0; }
};
void ExecuteThread(SomeClass* c) {
c = new SomeClass();
c->value = 555;
}
int main(int argc, char** argv) {
SomeClass* c = nullptr;
// std::ref(c) doesn't work
// Have also tried passing std::shared_ptr<SomeClass>
std::thread t1 = std::thread(&ExecuteThread, c);
t1.join();
std::cout << "c: " << c << "\n";
std::cout << "c->value: " << c->value << "\n";
return 0;
}

Answer 1

Just so that people do not get confused by incorrect self-answer, I am providing my own, correct answer.
The prime issue with OPs code is the fact that passing pointer by value copies the pointer, and any modification to it will not affect the original. Threads do not change this fact, and do add nothing to it. In particular, the code can be illustrated as
void change(int* k) {
k = nullptr;
}
int i;
k = &i;
change(k);
// k here is still the same as before calling `change`
If one wants to change passed pointer, it should be passed as a reference: void change(int*& k).
Having threads here changes things slightly. Since there is no way to pass something to a std::thread constructor by reference, std::ref needs to be used. The function signature should still accept pointer by reference, and std::ref should be used where thread is created:
auto t = std::thread(change, std::ref(k))

Answer 2

std::thread secretly makes copies of everything you pass as an argument including pointer data. This is incredibly misleading. The only way around that is to pass an address to a pointer and have the thread copy that. Then in your thread's task, deference to a pointer.
#include <thread>
#include <iostream>
class SomeClass {
public:
int value;
SomeClass() { value = 0; }
};
void ExecuteThread(SomeClass** c) {
*c = new SomeClass();
*c->value = 555;
}
int main(int argc, char** argv) {
SomeClass* c = nullptr;
std::thread t1 = std::thread(&ExecuteThread, &c);
t1.join();
std::cout << "c: " << c << "\n";
std::cout << "c->value: " << c->value << "\n";
return 0;
}