C++ - запустить функцию перед инициализацией члена класса

Оператор запятой на помощь! Выражение (a, b) сначала вычислит a, а затем b.

class DisplayOpenGL {
public:
    DisplayOpenGL(HWND hwnd)
    : m_device(hwnd),
      m_opengl((m_device.SetPixelFormat(), m_device)) { };
private:
    DeviceContext m_device;
    OpenGLContext m_opengl;
};

Всегда ли мне в таких случаях нужно решение на основе интеллектуальных указателей?

Нет. Избегайте этого ненужного осложнения.

Два непосредственных подхода, которые не были упомянуты:

Подход А:

Чистый путь.

Создайте небольшой объект-контейнер для хранилища m_device, который вызывает SetPixelFormat() в конструкторе. Затем замените DisplayOpenGL ::m_device экземпляром этого типа. Порядок инициализации получен, и цель вполне ясна. Иллюстрация:

class DisplayOpenGL {
public:
    DisplayOpenGL(HWND hwnd)
        : m_device(hwnd),
            m_opengl(m_device) { }
private:
    class t_DeviceContext {
    public:
        t_DeviceContext(HWND hwnd) : m_device(hwnd) {
            this->m_device.SetPixelFormat();
        }
        // ...
    private:
        DeviceContext m_device;
    };
private:
    t_DeviceContext m_device;
    OpenGLContext m_opengl;
};

Подход Б:

Быстрый и грязный способ. В этом случае вы можете использовать статическую функцию:

class DisplayOpenGL {
public:
    DisplayOpenGL(HWND hwnd)
    : m_device(hwnd),
      m_opengl(InitializeDevice(m_device)) { }
private:
    // document why it must happen this way here
    static DeviceContext& InitializeDevice(DeviceContext& pDevice) {
      pDevice.SetPixelFormat();
      return pDevice;
    }
private:
    DeviceContext m_device;
    OpenGLContext m_opengl;
};

Если OpenGLContext имеет конструктор аргументов 0 и конструктор копирования, вы можете изменить свой конструктор на

DisplayOpenGL(HWND hwnd)
: m_device(hwnd)
{
    m_device.SetPixelFormat();
    m_opengl = OpenGLContext(m_device);
};

unique_ptr обычно используется, когда вы хотите сделать один из элементов необязательным или «обнуляемым», что вы можете или не хотите делать здесь.

Использование uniqe_ptr для обоих здесь кажется уместным: вы можете перенаправить объявление DeviceContext и OpenGLContext вместо включения их заголовков, что составляет хорошо). Тогда это работает:

class DisplayOpenGL
{
public:
  DisplayOpenGL( HWND h );
private:
  unique_ptr<DeviceContext> m_device;
  unique_ptr<OpenGLContext> m_opengl;
};

namespace
{
  DeviceContext* InitDev( HWND h )
  {
    DeviceContext* p = new DeviceContext( h );
    p->SetPixelFormat();
    return p;
  }
}

DisplayOpenGL::DisplayOpenGL( HWND h ):
  m_device( InitDev( h ) ),
  m_opengl( new OpenGLContext( *m_device ) )
{
}

Если вы можете использовать С++ 11, вы можете заменить InitDev() на лямбду.

Во-первых, вы делаете это неправильно. :-) Очень плохая практика делать сложные вещи в конструкторах. Всегда. Сделайте эти операции функциями вспомогательного объекта, который вместо этого должен быть передан в конструктор. Лучше создавать свои сложные объекты вне вашего класса и передавать их полностью созданными, таким образом, если вам нужно передать их другим классам, вы можете сделать это в ИХ конструкторах одновременно. Кроме того, таким образом у вас есть шанс обнаружить ошибки, добавить разумное ведение журнала и т. д.

class OpenGLInitialization
{
public:
    OpenGLInitialization(HWND hwnd)
        : mDevice(hwnd) {}
    void                 SetPixelFormat  (void)       { mDevice.SetPixelFormat(); }
    DeviceContext const &GetDeviceContext(void) const { return mDevice; }
private:
    DeviceContext mDevice;
};        

class DisplayOpenGL 
{
public:
    DisplayOpenGL(OpenGLInitialization const &ogli)
    : mOGLI(ogli),
      mOpenGL(ogli.GetDeviceContext())
      {}
private:
    OpenGLInitialization mOGLI;
    OpenGLContext mOpenGL;
};

Если он принадлежит DeviceContext (и так кажется из вашего кода), вызовите его из DeviceContext c'tor.

Объедините оператор запятой с IIFE (Immediately-Invoked Function Expression), который позволяет вам определять переменные и другие сложные вещи, недоступные только с помощью оператора запятой:

struct DisplayOpenGL {
    DisplayOpenGL(HWND hwnd)
        : m_device(hwnd)
        , opengl(([&] {
            m_device.SetPixelFormat();
        }(), m_device))
    DeviceContext m_device;
    OpenGLContext m_opengl;
};

В вашем случае оператор запятой вполне подойдет, но я думаю, что эта проблема является следствием плохого планирования ваших занятий. Я бы позволил конструкторам инициализировать только состояние объектов, а не зависимости (например, контекст рендеринга OpenGL). Я предполагаю, что конструктор OpenGLContext инициализирует контекст рендеринга OpenGL, и я бы этого не сделал. Вместо этого я бы создал метод CreateRenderingContext для класса OpenGLContext для выполнения инициализации, а также для вызова SetPixelFormat

class OpenGLContext {
public:
    OpenGLContext(DeviceContext* deviceContext) : m_device(deviceContext) {}
    void CreateRenderingContext() {
        m_device->SetPixelFormat();
        // Create the rendering context here ...
    }
private: 
    DeviceContext* m_device;
};

...

DisplayOpenGL(HWND hwnd) : m_device(hwnd), m_opengl(&m_device) {
    m_opengl.CreateRenderingContext();
}