Nella documentazione di std::memory_ordersu cppreference.com c'è un esempio di ordinamento semplificato : Ordinazione rilassata Le operazioni atomiche contrassegnate memory_order_relaxednon sono operazioni di sincronizzazione; non impongono un ordine tra gli accessi simultanei alla memoria. Garantiscono solo atomicità e coerenza dell'ordine di modifica. Ad esempio, con xey inizialmente zero, // Thread 1: …
Il codice seguente viene compilato con gcc e clang (e molti altri compilatori C ++ 11) #include <stdint.h> typedef int datatype; template <typename T> struct to_datatype {}; template <> struct to_datatype<int16_t> { static constexpr datatype value = 1; }; template <typename T> class data { public: data(datatype dt = to_datatype<T>::value) …
Cerco di comprendere i tipi di espressione di C ++ e più leggo, più sono confuso, poiché trovo la bozza di C ++ molto difficile da digerire e quindi preferisco altre risorse ma si contraddicono a vicenda o non tengono conto del fatto che il la formulazione e la definizione …
Mi sono imbattuto in queste affermazioni: resize(n)- Ridimensiona il contenitore in modo che contenga 'n' elementi. shrink_to_fit()- Riduce la capacità del contenitore di adattarsi alle sue dimensioni e distrugge tutti gli elementi oltre la capacità. C'è qualche differenza significativa tra queste funzioni? vengono sotto vettori in c ++
Conosco le funzioni generate dal compilatore, la regola di tre e la regola di cinque. In scenari del mondo reale, potrebbe non essere banale capire esattamente quale delle funzioni generate dal compilatore (costruttori, operatori di assegnazione, distruttore) siano state effettivamente create dal compilatore. Esiste un modo per elencare le funzioni …
Qualche idea sul perché il seguente frammento non venga compilato? Si lamenta di un errore "errore: operandi a?: Tipi diversi" auto lambda1 = [&](T& arg) { ... }; auto lambda2 = [&](T& arg) { ... }; auto lambda = condition ? lambda1 : lambda2;
Il seguente (esempio inventato) va bene o è un comportamento indefinito: // undefined behavior? const auto& c = SomeClass{}; // use c in code later const auto& v = c.GetSomeVariable();
Una funzione sovraccarica dovrebbe includere entrambi i funzione, dato che il tipo di lambda è decidibile (calcolabile su un std::function(per favore correggimi se sbaglio). La domanda è: perché c'è un errore di compilazione sotto, nonostante il tipo lambda sia esplicitamente definito? ( [&]() -> Type {}) Si noti che per …
Ho un codice che trova e stampa le corrispondenze di uno schema mentre passa sopra il contenitore di stringhe. La stampa viene eseguita nella funzione foo che è modellata Il codice #include <iostream> #include <algorithm> #include <iterator> #include <vector> #include <string> #include <tuple> #include <utility> template<typename Iterator, template<typename> class Container> …
Considera questo programma: #include <cstdint> using my_time_t = uintptr_t; int main() { const my_time_t t = my_time_t(nullptr); } Impossibile compilare con msvc v19.24: <source>(5): error C2440: '<function-style-cast>': cannot convert from 'nullptr' to 'my_time_t' <source>(5): note: A native nullptr can only be converted to bool or, using reinterpret_cast, to an integral …
Ho letto sulla rimozione del riferimento di un tipo, qui . Dà il seguente esempio: #include <iostream> // std::cout #include <type_traits> // std::is_same template<class T1, class T2> void print_is_same() { std::cout << std::is_same<T1, T2>() << '\n'; } int main() { std::cout << std::boolalpha; print_is_same<int, int>(); print_is_same<int, int &>(); print_is_same<int, int …
C'è std::array<T, N>::size(), ma non è statico, quindi richiede un'istanza di std::array. C'è un modo per ottenere il valore che restituisce (che è il Nof std::array<T, N>) senza dover costruire un'istanza dell'array? Per un array normale, avrei potuto usare sizeof, ma non vedo alcuna garanzia che sizeof(std::array<T, N>) == N …
Ho un wrapper per qualche codice legacy. class A{ L* impl_; // the legacy object has to be in the heap, could be also unique_ptr A(A const&) = delete; L* duplicate(){L* ret; legacy_duplicate(impl_, &L); return ret;} ... // proper resource management here }; In questo codice legacy, la funzione che …
So che std::arrayè completamente allocato nello stack, ma questa domanda è motivata da problemi di sicurezza che richiedono due cose: I dati std::arraysaranno zerod o randomizzati alla distruzione I dati in std::arrayingresso verranno bloccati , in modo tale da non andare mai sul disco né in caso di arresto anomalo …
We use cookies and other tracking technologies to improve your browsing experience on our website,
to show you personalized content and targeted ads, to analyze our website traffic,
and to understand where our visitors are coming from.
By continuing, you consent to our use of cookies and other tracking technologies and
affirm you're at least 16 years old or have consent from a parent or guardian.