std::strong_ordering cmp = .... ;

  if( cmp ) // error
    {
    }
  else
    {
     Printf(Con,"equal\n");
    }

  switch( cmp ) // error
    {
     case std::strong_ordering::less : break; // error

     case std::strong_ordering::greater : break; // error

     case std::strong_ordering::equal : break; // error
    }

  class strong_ordering
  {
    __cmp_cat::type _M_value;

    ....

  public:

    ....

    constexpr operator int() const { return _M_value; }   

#if 1

    friend constexpr bool
    operator==(strong_ordering __v, int t) noexcept
    { return __v._M_value == t; }

    friend constexpr bool
    operator!=(strong_ordering __v, int t) noexcept
    { return __v._M_value != t; }

    friend constexpr bool
    operator< (strong_ordering __v, int t) noexcept
    { return __v._M_value < t; }

    friend constexpr bool
    operator> (strong_ordering __v, int t) noexcept
    { return __v._M_value > t; }

    friend constexpr bool
    operator<=(strong_ordering __v, int t) noexcept
    { return __v._M_value <= t; }

    friend constexpr bool
    operator>=(strong_ordering __v, int t) noexcept
    { return __v._M_value >= t; }

    friend constexpr bool
    operator< (int t, strong_ordering __v) noexcept
    { return t < __v._M_value; }

    friend constexpr bool
    operator> (int t, strong_ordering __v) noexcept
    { return t > __v._M_value; }

    friend constexpr bool
    operator<=(int t, strong_ordering __v) noexcept
    { return t <= __v._M_value; }

    friend constexpr bool
    operator>=(int t, strong_ordering __v) noexcept
    { return t >= __v._M_value; }

    friend constexpr strong_ordering
    operator<=>(strong_ordering __v, int /*zero*/) noexcept
    { return __v; }

    friend constexpr strong_ordering
    operator<=>(int /*zero*/, strong_ordering __v) noexcept
    { return strong_ordering(__cmp_cat::_Ord(-__v._M_value)); }

#endif

    ....

    // comparisons

    friend constexpr bool
    operator==(strong_ordering, strong_ordering) noexcept = default;

#if 0

    friend constexpr bool
    operator==(strong_ordering __v, __cmp_cat::__unspec) noexcept
    { return __v._M_value == 0; }

    friend constexpr bool
    operator< (strong_ordering __v, __cmp_cat::__unspec) noexcept
    { return __v._M_value < 0; }

    friend constexpr bool
    operator> (strong_ordering __v, __cmp_cat::__unspec) noexcept
    { return __v._M_value > 0; }

    friend constexpr bool
    operator<=(strong_ordering __v, __cmp_cat::__unspec) noexcept
    { return __v._M_value <= 0; }

    friend constexpr bool
    operator>=(strong_ordering __v, __cmp_cat::__unspec) noexcept
    { return __v._M_value >= 0; }

    friend constexpr bool
    operator< (__cmp_cat::__unspec, strong_ordering __v) noexcept
    { return 0 < __v._M_value; }

    friend constexpr bool
    operator> (__cmp_cat::__unspec, strong_ordering __v) noexcept
    { return 0 > __v._M_value; }

    friend constexpr bool
    operator<=(__cmp_cat::__unspec, strong_ordering __v) noexcept
    { return 0 <= __v._M_value; }

    friend constexpr bool
    operator>=(__cmp_cat::__unspec, strong_ordering __v) noexcept
    { return 0 >= __v._M_value; }

    friend constexpr strong_ordering
    operator<=>(strong_ordering __v, __cmp_cat::__unspec) noexcept
    { return __v; }

    friend constexpr strong_ordering
    operator<=>(__cmp_cat::__unspec, strong_ordering __v) noexcept
    { return strong_ordering(__cmp_cat::_Ord(-__v._M_value)); }

#endif
  };

inline constexpr int CmpLess = std::strong_ordering::less ;

inline constexpr int CmpGreater = std::strong_ordering::greater ;

inline constexpr int CmpEqual = std::strong_ordering::equal ;

  auto cmp = .... ; // вместо std::strong_ordering

  if( cmp ) // ok
    {
    }
  else
    {
     Printf(Con,"equal\n");
    }

  switch( cmp ) // ok
    {
     case CmpLess : break; // ok

     case CmpGreater : break; // ok

     case CmpEqual : break; // ok
    }

    std::string s = "Hello World!";
    std::stringstream ss;
    ss << s; // поехали
    ss >> s; // приехали

//1
class storage
{
    class blob
    {
    };
};

//2
namespace storage
{
    class storage;
    class blob;
}

//3
class storage;
class storage_blob;

K>>//1
K>>class storage
K>>

S>class A {
S>   struct impl;
S>   std::unique_ptr<impl> impl_;

S>private:
S>   ~A();
S>   ...
S>};
S>

//Storage.h
struct Storage
{
    struct Blob
    {

    };
};

struct Storage;
void foo(Stroage *stg);

struct Storage::Blob;
void foo(Storage::Blob *blob);

std::kokoko::algoritmi::ubrat_posledniy<std::kokoko::algoritmi::dla_vectora<std::kokoko::algorimti::intov>>(
std::kokoko::algoritmi::ubrat_perviy<std::kokoko::algoritmi::dla_vectora<std::kokoko::algorimti::intov>>(

std::kokoko::algoritmi::rangi<std::kokoko::algoritmi::dla_vectora<std::kokoko::algorimti::intov>>::sdelat_rang::dla_vectora<std::kokoko::algorimti::intov>
)
).each(...)

int main() 
{
    std::vector<int> v = { 3, 1, 4 };

    // since C++20 the signed size (ssize) can avail
    int i = ssize(v);
    for (--i; i != -1; --i) {
        std::cout << v[i] << ' ';
    }
    std::cout << "\n" "i = " << i << '\n';
}

prog.cc: In function 'int main()':
prog.cc:20:18: warning: conversion from 'std::common_type_t<long int, long int>' {aka 'long int'} to 'int' may change value [-Wconversion]
20 | int i = ssize(v);
| ~~~~~^~~

Proposals for which further work is encouraged:
...
Forward declarations of nested classes. This would allow things like X::A* to appear in a header without requiring a definition for X to also appear in the header (forward-declarations of X and X::A will be sufficient). EWG found the use case compelling, because currently a lot of class definitions to appear in headers only because interfaces defined in the header use pointers or references to nested classes of the type. Several details still need to be worked out. (For example, what happens if a definition of X does not appear in any other translation unit (TU)? What happens if a definition of X appears in another TU, but does not define a nested class A? What happens if it does define a nested class A, but it’s private? The answer to some or all of these may have to be “ill-formed, no diagnostic required”, because diagnosing errors of this sort would require significant linker support.)

skb=skb_rb_next(skb);
skb_rbtree_walk_from(skb){
}

S>>class A {
S>>   struct impl;
S>>   std::unique_ptr<impl> impl_;

S>>private:
S>>   ~A();
S>>   ...
S>>};
S>>

class A {
   struct impl;
   std::unique_ptr<impl> impl_;

K>struct Storage;
K>void foo(Stroage *stg);
K>

K>struct Storage::Blob;
K>void foo(Storage::Blob *blob);
K>

K>struct Storage::Blob;
K>void foo(Storage::Blob *blob);
K>

// main_iface.h
#ifndef MAIN_IFACE_H
#define MAIN_IFACE_H

class storage {
public:
    class blob;
};

storage::blob* make_blob();
int using_blob(storage::blob* b);

#endif /* MAIN_IFACE_H */

// main_impl.cpp
#include "main_iface.h"

class storage::blob {
public:
  int finish() {
    return 42;
  }
};

storage::blob* make_blob() {
  return new storage::blob();
}

int using_blob(storage::blob* b) {
  return b->finish();
}

// main.cpp
#include "main_iface.h"
#include <iostream>

int main() {
    std::cout << using_blob(make_blob()) << "\n";
    return 0;
}

    for (size_t i = 1; 1 + i < v.unsigned_size(); ++i)
    {
        v[i];
    }

Так ведь не сломано ничего. Исправлять незачем.

    std::list<int> lst; // std::vector<int> lst;
    lst.push_back(1);
    lst.push_back(2);
    lst.push_back(3);
    lst.push_back(4);

    for (auto it = lst.begin(); it != lst.end(); it++)
    {
        if (*it % 2)
            lst.insert(it, *it);
    }

    skb_rbtree_walk_from(skb) {
        int in_sack = 0;
        bool dup_sack = dup_sack_in;
        ...

struct Foo; // поехали
struct Foo::Bar; // приехали

struct Foo
{
    struct Bar
    {
    };
};

K>//1
K>class storage
K>{
K>    class blob
K>    {
K>    };
K>};

K>//2
K>namespace storage
K>{
K>    class storage;
K>    class blob;
K>}

K>//3
K>class storage;
K>class storage_blob;

K>

class A {
   struct impl;
   std::unique_ptr<impl> impl_;

private:
   ~A();
   ...
};

class storage;
class storage::blob;

    for (int i = 1; i < v.signed_size() - 1; i++)
    {
        v[i];
    }

    for (size_t i = 1; i < v.unsigned_size() - 1; i++)
    {
        v[i];
    }

K>class storage;
K>

Proposals for which further work is encouraged:
...
Forward declarations of nested classes. This would allow things like X::A* to appear in a header without requiring a definition for X to also appear in the header (forward-declarations of X and X::A will be sufficient). EWG found the use case compelling, because currently a lot of class definitions to appear in headers only because interfaces defined in the header use pointers or references to nested classes of the type. Several details still need to be worked out. (For example, what happens if a definition of X does not appear in any other translation unit (TU)? What happens if a definition of X appears in another TU, but does not define a nested class A? What happens if it does define a nested class A, but it’s private? The answer to some or all of these may have to be “ill-formed, no diagnostic required”, because diagnosing errors of this sort would require significant linker support.)

K>    double len = 0;
K>    for (int i = 0; i < points.size() - 1; i++)
K>        len += distance(point[i], point[i + 1]);
K>    return len;

K>

if(i >= 0 && i < N)

K>>    double len = 0;
K>>    for (int i = 0; i < points.size() - 1; i++)
K>>        len += distance(point[i], point[i + 1]);
K>>    return len;

K>>

S>if(i >= 0 && i < N)
S>

if (vec.valid_index(i))

Note: Unsigned arithmetic does not overflow. Overflow for
signed arithmetic yields undefined behavior (7.1). —end note

If during the evaluation of an expression, the result is not mathematically defined or not in the range of
representable values for its type, the behavior is undefined.

  std::strong_ordering cmp = .... ;

  if( cmp != 0 ) // ok
    {
    }
  else
    {
    }

  if (cmp < 0) { // ok
  } else if (cmp > 0) { // ok
  } else { // ok
  }

inject_pending_event:
else if (vcpu->arch.interrupt.injected)
kvm_x86_ops->set_irq(vcpu);