Указатель на привязанную функцию можно использовать только для вызова функции

class Logger;
 
class Parent {
public:
    Logger* logger;
    bool work = false;
    thread* functhread;
    string name = "Worker";
    void Main();
    Parent(Logger* l);
    void Exit();
};
 
Parent::Parent(Logger* l) {
    this->logger = l;
    this->work = true;
    this->logger->SendSignal(this, STARTED, "[" + name + "] Starting...");
    this->functhread = new thread(this->Main); // Здесь ошибка
}

this->functhread = new thread(&Parent::Main,this);

#include <iostream>
#include <SFML/Graphics.hpp>
#include <thread>
#include <chrono>
#include <condition_variable>
#include <vector>
#include <string.h>
 
#pragma comment(lib, "sfml-audio.lib")
#pragma comment(lib, "sfml-graphics.lib")
#pragma comment(lib, "sfml-network.lib")
#pragma comment(lib, "sfml-system.lib")
#pragma comment(lib, "sfml-window.lib")
 
using namespace std;
 
enum LoggerMessageLevel {
    DEBUG = -1,
    INFO,
    WARN,
    ERROR,
    FATAL,
    STARTED,
    STOPPED
};
 
class Logger;
 
class Parent {
public:
    Logger* logger;
    bool work = false;
    thread* functhread;
    string name = "Worker";
    void Main() {}
    Parent(Logger* l);
    void Exit();
};
 
class Logger {
public:
    ostream* strm;
    vector<string> pool;
    vector<Parent*> threads;
    using threadsIter = vector<Parent*>::iterator;
    using poolIter = vector<string>::iterator;
    bool work;
    Logger(ostream*);
    void LoggerWorker();
    threadsIter FindThread(Parent*);
    void SendSignal(Parent*, LoggerMessageLevel, string);
};
 
Parent::Parent(Logger* l) {
    this->logger = l;
    this->work = true;
    this->logger->SendSignal(this, STARTED, "[" + name + "] Starting...");
    this->functhread = new thread(&Parent::Main, this);
}
void Parent::Exit() {
    this->work = false;
    this->logger->SendSignal(this, STOPPED, "[" + name + "] Stopped!");
}
 
Logger::Logger(ostream * stream) {
    this->strm = stream;
    this->work = true;
}
void Logger::LoggerWorker()
{
    if (!this->work) { if (this->strm->good()) { this->strm->operator<<("[DEBUG] Logger isn't inited!"); } }
    while (this->work) {
        for (poolIter iter = this->pool.end(); iter != this->pool.begin(); iter--) {
            this->strm->operator<<((*iter).c_str());
        }
        this_thread::sleep_for(chrono::milliseconds(10));
    }
    this->strm->operator<<("[DEBUG] Logger is stopped!");
}
Logger::threadsIter Logger::FindThread(Parent* elem) {
    for (Logger::threadsIter iter = this->threads.begin(); iter != this->threads.end(); iter++) { if (*iter == elem) { return iter; } }
}
void Logger::SendSignal(Parent* elem, LoggerMessageLevel level, string message) {
    string formatted;
    if (level == STARTED) {
        this->threads.push_back(elem);
    }
    if (level == STOPPED) {
        this->threads.erase(FindThread(elem), FindThread(elem));
    }
    if (level == FATAL) {
        for (auto& thrd : this->threads) {
            thrd->Exit();
        }
        this->work = false;
    }
}
 
class Window : public Parent {
    Window(Logger* l) : Parent(l) {}
    void Main();
};
 
class Window : public Parent {
    string name = "Window-Worker";
    Window(Logger* l) : Parent(l) {}
    void Main() {
        {
            sf::RenderWindow window(sf::VideoMode(200, 200), "SFML works!");
 
            while (window.isOpen())
            {
                sf::Event event;
                while (window.pollEvent(event))
                {
                    if (event.type == sf::Event::Closed)
                        window.close();
                }
 
                window.clear();
                window.display();
            }
        }
    }
};
 
int main()
{
    Logger* logger = new Logger(&cout);
    Window* window = new Window(logger);
 
    thread* lthread = new thread(&Logger::LoggerWorker, logger);
}

#include <string>
#include <thread>
#include <iostream>
#include <chrono>
 
class Parent {
public:
    Parent() : functhread{new std::thread(&Parent::Main, this)} {}
    virtual void Main() {
        std::cout << "DEFAULT" << std::endl;
    }
    virtual ~Parent() {
    }
private:
    std::thread *functhread;
};
 
class Window : public Parent {
public:
    Window() : Parent() {}
    void Main() override {
        std::cout << "I'm done!" << std::endl;
    }
};
 
int main() {
    Window window;
 
    std::this_thread::sleep_for(std::chrono::seconds(1));
}

#include <string>
#include <thread>
#include <iostream>
#include <chrono>
 
class Parent {
public:
    Parent() : functhread{new std::thread(&Parent::Main, this)} {
        functhread->join(); // подождём
    }
    virtual void Main() {
        std::cout << "DEFAULT" << std::endl;
    }
    virtual ~Parent() {
    }
private:
    std::thread *functhread;
};
 
class Window : public Parent {
public:
    Window() : Parent() {}
    void Main() override {
        std::cout << "I'm done!" << std::endl;
    }
};
 
int main() {
    Window window;
 
    std::this_thread::sleep_for(std::chrono::seconds(1));
}

class Logger;
 
class Parent {
public:
    Logger* logger;
    bool work = false;
    thread functhread;
    string name = "Worker";
    void Main();
    Parent(Logger* l);
    void Exit();
};
 
Parent::Parent(Logger* l) 
    : logger(l), work(true), functhread(&Parent::Main, this)  
{
    this->logger->SendSignal(this, STARTED, "[" + name + "] Starting...");
}

sf::RenderWindow* window;
    map<Parent*, sf::Drawable*> pool;
    using poolIter = map<Parent*, sf::Drawable*>::iterator;
void Main() override {
        window = new sf::RenderWindow{ sf::VideoMode(x, y), NAME, sf::Style::Close | sf::Style::Titlebar };
        
        while (window->isOpen() && work)
        {
            window->clear();
            for (auto& sp : pool) {
                window->draw(*sp.second);
            }
            window->display();
        }

void Logger::RemoveThread(Parent* elem) {
    for (auto iter = this->threads.begin(); iter != this->threads.end(); iter++) {
        if (*iter == elem) {
            this->threads.erase(iter); 
        } 
    }
}

void Logger::RemoveThread(Parent* elem) {
    size_t i = 0;
    size_t threads_c = this->threads.size();
    bool done = false;
    while (!done) {
        i = 0;
        threads_c = this->threads.size();
        for (auto iter = this->threads.begin(); iter != this->threads.end(); iter++) {
            cout << to_string(i) << ";" << to_string(threads_c) << ";" << to_string(this->threads.size()) << "\n";
            if (threads_c != this->threads.size()) { break; }
            assert(i < this->threads.size());
            if (*iter == elem) {
                this->threads.erase(iter);
                done = true;
            }
            i++;
        }
    }
}