"это не важно, важен лишь цвет травы..."

>говорят что я должен научить студента компилировать эти исходники

    _keyConstraintsTable =
        opCtx->getServiceContext()->getStorageEngine()->makeTemporaryRecordStoreFromExistingIdent(
            opCtx, ident);

  template <class TEvent, class TDeps, class TSubs,
            __BOOST_SML_REQUIRES(aux::is_base_of<get_mapped_t<TEvent>, events_ids_t>::value)>
  bool process_internal_event(const TEvent &event, TDeps &deps, TSubs &subs, state_t &current_state) {
    policies::log_process_event<sm_t>(aux::type<logger_t>{}, deps, event);
#if BOOST_SML_DISABLE_EXCEPTIONS  // __pph__
    return process_event_impl<get_event_mapping_t<get_mapped_t<TEvent>, mappings>>(event, deps, subs, states_t{}, current_state)
#else   // __pph__
    return process_event_except_imp<get_event_mapping_t<get_mapped_t<TEvent>, mappings>>(event, deps, subs, current_state,
                                                                                         has_exceptions{})
#endif  // __pph__
           || process_internal_generic_event(event, deps, subs, current_state);
  }

  template <class TMappings, class TEvent, class TDeps, class TSubs, class... TStates>
  bool process_event_impl(const TEvent &event, TDeps &deps, TSubs &subs, const aux::type_list<TStates...> &states,
                          aux::index_sequence<0>) {
    const auto lock = thread_safety_.create_lock();
    (void)lock;
    return dispatch_t::template dispatch<0, TMappings>(*this, current_state_[0], event, deps, subs, states);
  }

struct my_struct { // no ostream operator defined!
    std::string s;
    int i;
};

int main() {
    my_struct s{{"Das ist fantastisch!"}, 100};
    std::cout << "my_struct has " << boost::pfr::tuple_size<my_struct>::value
        << " fields: " << boost::pfr::io(s) << "\n";
}

my_struct has 2 fields: {"Das ist fantastisch!", 100}

#include <daw/json/daw_json_link.h>

struct Thing {
 int a;
 double b;    
};

namespace daw::json {
  template<>
  struct json_data_contract<Thing> {
    using type = json_member_list<
      json_number<"a", int>,
      json_number<"b">
    >;
  };
}
...

std::string str = to_json(Thing{ 42, 3.14 });

{
"a": 42,
"b": 3.14
}

auto ctx = opCtx->getServiceContext();
auto storage_engine = ctx->getStorageEngine();
auto store = storage_engine->makeTemporaryRecordStoreFromExistingIdent()

char* p = new (std::nothrow) char [MAX_UINT64]

    BSONObj& shareOwnershipWith(ConstSharedBuffer buffer) & {
        invariant(buffer);
        _ownedBuffer = buffer;
        return *this;
    }
    BSONObj& shareOwnershipWith(const BSONObj& other) & {
        shareOwnershipWith(other.sharedBuffer());
        return *this;
    }
    BSONObj&& shareOwnershipWith(ConstSharedBuffer buffer) && {
        return std::move(shareOwnershipWith(buffer));
    }
    BSONObj&& shareOwnershipWith(const BSONObj& other) && {
        return std::move(shareOwnershipWith(other));
    }

PM>>struct my_struct { // no ostream operator defined!
PM>>    std::string s;
PM>>    int i;
PM>>};

PM>>int main() {
PM>>    my_struct s{{"Das ist fantastisch!"}, 100};
PM>>    std::cout << "my_struct has " << boost::pfr::tuple_size<my_struct>::value
PM>>        << " fields: " << boost::pfr::io(s) << "\n";
PM>>}
PM>>

struct print_vars {
    template <typename T>
    void operator()(T const & x) const {
        std::cout << '<' << typeid(x).name() <<  ' ' << x << '>';
    };
};

// Your existing struct
struct Foo
{
    int i;
    bool j;
    char k[100];
};

// Generate an adapter allowing to view "Foo" as a Boost.Fusion sequence
BOOST_FUSION_ADAPT_STRUCT(
    Foo,
    (int, i)
    (bool, j)
    (char, k[100])
)

struct Foo f = { 33, false, "abcd" };
boost::fusion::for_each(f, print_vars());

class cowinotrid // short from complicated_with_non_trivial_dtor
{
   std::string data;
   cowinotrid(std::string data) : data(data)
   {
      for (int i = 0; i < 1000; ++i) data += data; // to be longer than small string optimization length 
   }
};

my_own_vector<cowinotrid> vec{ "hallo welt" }; 
while (vec.size() <= vec.capacity()) // i want to reallocate
{
    vec.push_back(vec[0]);
}
assert(vec.size() == 2);

Тё>Я был лучшего мнения о C++ программистах

Тё>Если программист C++ понимает эти вещи- он их учтёт в реализации вектора. А если "программист C++" ака говнокодер вульгарис, кто утверждает, что на жава только опердни в индийском аутсорсе, что ж

int main()
{
    my_vector<std::string> vec;
    vec.push_back("hallo welt! the string is longer than 24 characters to run over SSO"); 
    for (int i = 0; i <1000; ++i)
    {
        vec.push_back(vec[0]);
    }
}

int avg (int si_a, int si_b)
{
    if ((si_b > 0) && (si_a > (INT_MAX - si_b)))
    {
      if (si_a >= si_b)
        return si_b + (si_a - si_b) / 2;
      else
        return si_a + (si_b - si_a) / 2;
    } 
    else if ((si_b < 0) && (si_a < (INT_MIN - si_b)))
    {
      if (si_a <= si_b)
        return si_b + (si_a - si_b) / 2;
      else
        return si_a + (si_b - si_a) / 2;
    }
    else
    {
      return (si_a + si_b) / 2;
    }
}