class Class1
{
public:
    Class1();
};

#include "test.h"

Class1::Class1()
{

}

class Class1
{
public:
    Class1(){}
};

// .hpp-файл.
class Class2; // Предварительное объявление.

class Class1 {
  Class2 member_;
  ...
public:
  Class1() {}
  ...
};

// .cpp-файл.
class Class2 { ... }; // Полное определение.

// .h

class class1;

class class2 {

  class2();

  std::unique_ptr<class1> ptr;
}

// .cpp

#include "class1.h"

class2::class2()
{
}

#include <memory>

class Class2;

class Class1
{
public:
    Class1();
private:
    std::unique_ptr<Class2> obj;
};

#include "Class1.h"

class Class2
{
};


Class1::Class1()
{

}

#include <memory>

class Class2;

class Class1
{
public:
    Class1();
private:
    std::unique_ptr<Class2> ptr;
};

#include "Class1.h"
#include "Class2.h"

Class1::Class1()
{
}

class Class2
{
};

V>// .h

V>class class1;

V>class class2 {

V>  class2();

V>  std::unique_ptr<class1> ptr;
V>}

V>// .cpp

V>#include "class1.h"

V>class2::class2()
V>{
V>}
V>

// .h
class Class2;

class Class1 {
  std::unique_ptr<Class2> ptr_member_{new Class2{}};
  ...
public:
  Class1();
  ~Class1();
  ...
};

// .cpp
class Class2 {...}

Class1::Class1() {}
Class1::~Class1() {}

template <typename T>
class MyPtr {
  T *ptr;

  public: 
  MyPtr() {
    ptr = new T();
  }
};

class Class2;

class Class1 {
  MyPtr<Class2> c2ptr;

  Class1() {}
};

class Class2 { };

A specialization for a function template, a member function template, or of a member function or static data member of a class template may have multiple points of instantiations within a translation unit, and in addition to the points of instantiation described above, for any such specialization that has a point of instantiation within the translation unit, the end of the translation unit is also considered a point of instantiation.

сlass Class2;

class Class1
{
public:
    Class1();
    ~Class1();
private:
    std::unique_ptr<Class2> ptr;
};

//... тут все тоже самое

// test.hpp
сlass Class2;

class Class1 {
    std::unique_ptr<Class2> ptr;
    // нет явного ~Class1(), так что компилятор создает inline версию
    // в которой пытается вызывать деструктор Class2 
};

// test.hpp
сlass Class2;

class Class1 {
    std::unique_ptr<Class2> ptr;
    ~Class1();
};

// test.cpp
#include "test.hpp"

class Class2 {}; // полное определение нужно в любом случае

Class1::~Class1() = default; // достаточно сгенерированной версии, главное чтобы Class2 был здесь доступен

/Users/test/Desktop/cmake_test/Class1.h:6:43: error: allocation of incomplete type 'Class2'
std::unique_ptr<Class2> ptr_member_{new Class2{}};
^~~~~~
/Users/test/Desktop/cmake_test/Class1.h:3:7: note: forward declaration of 'Class2'
class Class2;
^
1 error generated.
make[2]: *** [CMakeFiles/main.dir/main.cpp.o] Error 1

error: invalid application of 'sizeof' to an incomplete type 'Class2'
static_assert(sizeof(_Tp) > 0,
^~~~~~~~~~~

MyClass(){}

Попробуйте сделать и обломитесь.

// demo.hpp
#pragma once

#include <memory>

class Class2;

class Class1 {
    template<typename C>
    static int get_v() {
        C v;
        return v.value();
    }

    int v_{ get_v<Class2>() };

public:
    Class1();
    ~Class1();

    static std::unique_ptr<Class1> make();
};

// demo.cpp
#include "demo.hpp"

class Class2 {
public:
    int value() const { return 0; }
};

Class1::Class1() {}
Class1::~Class1() {}

std::unique_ptr<Class1> Class1::make() { return std::make_unique<Class1>(); }

#include "demo.hpp"

int main() {
    auto c = Class1::make();
}

In file included from main.cpp:1:
./demo.hpp:10:5: error: variable has incomplete type 'Class2'
                C v;
                  ^
./demo.hpp:14:10: note: in instantiation of function template specialization 'Class1::get_v<Class2>' requested here
        int v_{ get_v<Class2>() };
                ^
./demo.hpp:5:7: note: forward declaration of 'Class2'
class Class2;
      ^
1 error generated.

Американский форум- задал вопрос, тебе на него обстоятельно и вежливо ответят.
Еврейский форум- задал вопрос, тебе зададут встречный вопрос.
Русский форум-задал вопрос, тебе ещё 2 часа будут объяснять какой ты мудак!

class Class1
{
public:

   Class1();
   ~Class1();

private:

   class Impl;

   std::unique_ptr<Impl> m;
};

C:\Program Files\Microsoft Visual Studio\2022\Professional\VC\Tools\MSVC\14.34.31933\include\memory(3105,1): error C2027: use of undefined type 'Class1::Impl'

$ clang++-16 -o demo -std=c++17 main.cpp demo.cpp
In file included from main.cpp:1:
In file included from ./demo.hpp:3:
In file included from /usr/bin/../lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/memory:76:
/usr/bin/../lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/unique_ptr.h:83:16: error: invalid application of 'sizeof' to an incomplete type 'Class1::Impl'

class Class2;

class Class1 {
  std::unique_ptr<Class2> ptr_member_;
public:
  // Нет ни конструктора, ни деструктора.
};

int main() {
  Class1 c;
}

class Class2;

class Class1 {
  std::unique_ptr<Class2> ptr_member_;
public:
  // Нет ни конструктора, ни деструктора.

  static std::unique_ptr<Class1> make();
};

int main() {
  auto c = Class1::make();
}

class Class1 {
  std::unique_ptr<Class2> ptr_member_;

  void do_something(); // Реализовано в .cpp-файле.
  ...
};

void Class1::do_something() {
  if(!ptr_member_) ptr_member_ = std::make_unique<Class2>(...);
  ...
}

Мне не нужно знать в чем проблема была именно в том частном случае.
Мне нужно понимание почему вообще перенос пустого конструктора в H-файл может приводить к ошибке компиляции — какая разница компилятору?

#include <memory>

class Class1
{
public:

   // Class1() {}
   explicit Class1(int);
   ~Class1();

private:

   class Impl;

   std::unique_ptr<Impl> m;
};

int main()
{
}

g++ -std=c++11 -O2 -Wall -pedantic -pthread main.cpp && ./a.out
/usr/local/include/c++/12.1.0/bits/unique_ptr.h:93:23: error: invalid application of 'sizeof' to incomplete type 'Class1::Impl'
   93 |         static_assert(sizeof(_Tp)>0,
      |                       ^~~~~~~~~~~

In file included from /Users/test/Desktop/cmake_test/main.cpp:1:
/Users/test/Desktop/cmake_test/Class1.h:11:11: error: variable has incomplete type 'Class2'
C v;
^
/Users/test/Desktop/cmake_test/Class1.h:15:13: note: in instantiation of function template specialization 'Class1::get_v<Class2>' requested here
int v_{ get_v<Class2>() };
^
/Users/test/Desktop/cmake_test/Class1.h:6:7: note: forward declaration of 'Class2'
class Class2;
^
1 error generated.

#pragma once

#include <memory>

class Class1
{
public:

   Class1();
   ~Class1();

   static std::unique_ptr<Class1> make();

private:

   class Impl;

   std::unique_ptr<Impl> m;
};

#include "demo.hpp"

class Class1::Impl {
};

Class1::Class1() {}
Class1::~Class1() {}

std::unique_ptr<Class1> Class1::make() { return std::make_unique<Class1>(); }

#include "demo.hpp"

int main() {
    auto c = Class1::make();
}

template <class _Ty>
struct default_delete2;

template <class _Ty, class _Dx = default_delete2<_Ty>>
class unique_ptr2;

template <class _Ty, class _Dx>
class unique_ptr2 {
};

template <class _Ty>
struct default_delete2 { // default deleter for unique_ptr
    constexpr default_delete2() noexcept = default;

    inline void operator()(_Ty* _Ptr) const noexcept
    {
        static_assert(0 < sizeof(_Ty), "can't delete an incomplete type");
        delete _Ptr;
    }
};

template <class _Ty>
struct default_delete2;

template <class _Ty, class _Dx = default_delete2<_Ty>>
class unique_ptr2;

template <class _Ty, class _Dx>
class unique_ptr2 {
};

template <class _Ty>
struct default_delete2 { // default deleter for unique_ptr
    constexpr default_delete2() noexcept = default;

    inline void operator()(_Ty* _Ptr) const noexcept
    {
        static_assert(0 < sizeof(_Ty), "can't delete an incomplete type");
        delete _Ptr;
    }
};

#include <utility>

template <typename T>
struct MyDeleter
{
   void operator()(T* t) const
   {
       static_assert(sizeof(T), "Incomplete type");
       delete t;
   }
};

template <typename T, typename DeleterT = MyDeleter<T>>
class MySmartPtr
{
public:

   MySmartPtr() = default;
   explicit MySmartPtr(T* p, DeleterT deleter = {})
      : m_p(p), m_deleter(std::move(deleter)) {}

   T& operator * () const { assert(m_p); return *m_p; }
   T* operator -> () const { assert(m_p); return m_p; }
   explicit operator bool() const { return m_p != nullptr; }

   ~MySmartPtr()
   {
      if (m_p)
      {
         m_deleter(m_p);
      }
   }

private:
   T* m_p{};
   DeleterT m_deleter{};
};

class Class1
{
public:

   Class1(){}
   explicit Class1(int);
   ~Class1();

private:

   class Impl;

   MySmartPtr<Impl> m;
};

int main()
{
}