#include <variant>

struct D
{
    struct FService
    {
        int  nFService_ = 0;
    };

    std::variant<FService> data_;
};

int main() 
{
D d;
return 0;
}

#include <concepts>

struct D
{
    struct FService
    {
        int  nFService_ = 0;
    };

    static_assert(std::default_initializable<FService>); // error: static assertion failed
};

This declares a default constructor that might be defined implicitly by the compiler, **or** it might get deleted if the member definitions of D would make the implicit default constructor ill-formed. This is obviously very different from the case where you declare B(); There is no assertion that D is default constructible, the compiler has to deduce whether or not that's true. That depends on the default member initializer for D::i. The initializer (which is just '0' here) is a "complete class context" which means it is not processed until the class D is complete (this allows you to use other members, or e.g. sizeof(D) as the initializer).

A nested class like C::D is not complete until its enclosing class is complete. This means the initializer for C::D::i is compiled after C is complete. This means whether C::D is default constructible is not known until C is complete.

A nested class like C::D is not complete until its enclosing class is complete.

struct D
{
    struct FService
    {
        int  nFService_ = 0;
    };
    static_assert(sizeof(FService) != 0);  // OK
    static_assert(std::default_initializable<FService>); // static assertion failed
};

[Note 4 : A complete-class context of a nested class is also a complete-class context of any enclosing class, if the nested
class is defined within the member-specification of the enclosing class. — end note]
7 A class is considered a completely-defined object type (6.8) (or complete type) at the closing } of the
class-specifier. The class is regarded as complete within its complete-class contexts; otherwise it is regarded
as incomplete within its own class member-specification.

R>Ну вот, а мне тут про какие-то контексты лапшу на уши навешивают

using value_type = float;

struct A
{
  struct B
  {
     value_type n = 0;
  };
  using value_type = int;
};

R>>Ну вот, а мне тут про какие-то контексты лапшу на уши навешивают

BFE>using value_type = float;

BFE>struct A
BFE>{
BFE>  struct B
BFE>  {
BFE>     value_type n = 0;
BFE>  };
BFE>  using value_type = int;
BFE>};
BFE>

using value_t = float;

struct Outer {
    struct Inner {
        value_t i;
    };
    std::variant<Inner> v; // value_t = float, Inner - считается полным, конструктор создать можно, код компилируется
    using value_t = long long; // это переопределение уже никого не волнует, тип Inner готов
};

static constexpr int SuperDuperConst = 0;

struct Outer {
    struct Inner {
        int i = SuperDuperConst;
    };
    std::variant<Inner> v; // i должна быть равна 42, но мы ещё не добрались до определения SuperDuperConst и конструктор сгенерировать не можем - компиляция провалилась
    static constexpr int SuperDuperConst = 42;
};

BFE>using value_type = float;

BFE>struct A
BFE>{
BFE>  struct B
BFE>  {
BFE>     value_type n = 0;
BFE>  };
BFE>  using value_type = int;
BFE>};
BFE>

using value_type = float;

struct A
{
    static_assert(std::same_as<float, value_type>);
    using value_type = int;
    static_assert(std::same_as<int, value_type>);
};

using value_type = float;

struct O
{
  struct I
  {
     value_type n = 2.3;
  };
  using value_type = int;
};

int main() 
{
  O::I in;
  std::cout << in.n;
  return 0;
}

int f(int)
{
  return 0;
}

//template<class T = char> 
struct A
{
  int g() { return f(0); }           // здесь f - член класса       
  using value_Type = decltype(f(0)); // здесь f - внешняя функция?
  struct B
  {
     value_Type n = 1.1;
  } b;

   float f(int) { return 0;}
};

constexpr float f(int)
{
  return 0;
}

struct A
{
  using value_Type = decltype(f(0));
  struct B
  {
     value_Type             n = f(0);
     static constexpr auto  m = f(0);
  } b;

   static constexpr  int f(int) { return 5;}
};

int main() 
{
  A a;
  std::cout << "n=" << a.b.n << '\n';
  std::cout << "m=" << a.b.m << '\n';

  return 0;
}