Depuis auto et decltype sont tous deux utilisés pour déduire les types. Je pensais qu’ils seraient les mêmes. Cependant, la réponse à cette question suggère le contraire. Pourtant, je pense qu’ils ne peuvent pas être entièrement différents. Je peux penser à un exemple simple où le type de i sera le même dans les cas […]
J’utilise un mécanisme SFINAE pour déduire un type. Resolve::type est déduite de T si la class T ne contient pas yes et de MyClass si elle contient yes . class MyClass {}; template struct void_ { typedef void check; }; template struct Resolve { typedef T type; }; template struct Resolve <T, typename void_::check> { […]
En C ++, vous êtes autorisé à écrire une instruction return qui ressemble à ceci: return ( … ); qui est différent du plus populaire: return … ; En particulier, la première version renvoie l’adresse / la référence de quelque chose qui est local à la stack de la fonction qui contient cette instruction de […]
Quand j’ai répondu à ma propre question sur https://stackoverflow.com/a/32115498/383779 , j’ai eu un autre doute. Dans const CArray& Items= (ItemsInput!= nullptr)? *ItemsInput : [this]() -> const CArray& { CArray InnerItems; GetContainer().GetInnerItems(InnerItems, NULL, true); return (InnerItems); } () ; J’ai essayé de supprimer la partie -> const CArray& return, mais cela a -> const CArray& deux […]
Je suis conscient du fait que C ++ n’autorise qu’une seule conversion implicite définie par l’utilisateur lors de la conversion entre types. Cependant, je suis récemment tombé sur une situation où il semble qu’une double conversion implicite définie par l’utilisateur soit autorisée lors de l’initialisation. Considérez les classes suivantes: //fractions class Rational { public: int […]
Je travaille toujours sur une bonne solution à mon problème de conteneur One-Of-A-Type – et après reflection, je pense que ce serait bien de pouvoir utiliser quelque chose comme un std::map . Malheureusement, std::type_info ne définit pas d’ operator< , et je pense qu’il serait déraisonnable de le définir. Cependant, il semble raisonnable de définir […]
J’ai une variable CSsortingng qui ia besoin de convertir en LPCTSTR (const char *). J’ai besoin de cette conversion pour pouvoir l’utiliser comme argument dans une fonction. Le CSsortingng ressemble à: CSsortingng sqlTemp = _T(“INSERT INTO “+ sw1 +” (filename, “+ sw2 +”) VALUE (“+ sw7 +”,”+ sw3 +” ) “); Il contient une requête. […]
Considérer ce qui suit: template struct uint_ { }; template struct X { static constexpr bool value = false; }; template // NB: int, not unsigned struct X<uint_> { static constexpr bool value = true; }; int main() { static_assert(X<uint_>::value, “!”); } Clang comstack le code, pas gcc. Cependant, dans l’exemple suivant hautement lié: template […]
J’ai le code suivant: class A { public: operator int() const { return 5; } }; class B { public: operator int() const { return 6; } }; int main() { A a; B b; int myInt = true ? a : b; return 0; } Une tentative de compilation de ce code avec Visual […]
Maintenant que shared_ptr est dans tr1, que pensez-vous qu’il devrait arriver à l’utilisation de std::auto_ptr ? Ils ont tous deux des cas d’utilisation différents, mais tous les cas d’utilisation de auto_ptr peuvent également être résolus avec shared_ptr . Allez-vous abandonner auto_ptr ou continuer à l’utiliser dans les cas où vous souhaitez exprimer explicitement qu’une seule […]