Yes your reasoning is correct, that is how these different forms of array declarations and definitions are viewed by C and C++. As others already stated, VLA with a veritable variable length (non-const) in global scope is difficult to make sense. What would the evaluation order be, e.g if the the length expression would refer … Read more
Avoiding the cost of a function call is only half the story. do: use inline instead of #define very small functions are good candidates for inline: faster code and smaller executables (more chances to stay in the code cache) the function is small and called very often don’t: large functions: leads to larger executables, which … Read more
You have to understand the forwarding problem. You can read the entire problem in detail, but I’ll summarize. Basically, given the expression E(a, b, … , c), we want the expression f(a, b, … , c) to be equivalent. In C++03, this is impossible. There are many attempts, but they all fail in some regard. … Read more
This code snippet: int& func1() { int i; i = 1; return i; } will not work because you’re returning an alias (a reference) to an object with a lifetime limited to the scope of the function call. That means once func1() returns, int i dies, making the reference returned from the function worthless because … Read more
There are a couple ways to check this compile time, but they might not always work for you. Start by inserting a “marker” enum value right before MsgFoo2A. typedef enum { MsgFoo1A = BASE1_VAL, MsgFoo1B, MsgFoo1C, MsgFoo1D, MsgFoo1E, MARKER_1_DONT_USE, /* Don’t use this value, but leave it here. */ MsgFoo2A = BASE2_VAL, MsgFoo2B } FOO; … Read more
In two first cases RVO optimization will take place. RVO is old feature and most compilers supports it. The last case is so called NRVO (Named RVO). That’s relatively new feature of C++. Standard allows, but doesn’t require implementation of NRVO (as well as RVO), but some compilers supports it. You could read more about … Read more
I think testing if it is an enum and not implicitly convertible to the underlying type should do the trick. template <typename T, bool B = std::is_enum<T>::value> struct is_scoped_enum : std::false_type {}; template <typename T> struct is_scoped_enum<T, true> : std::integral_constant<bool, !std::is_convertible<T, typename std::underlying_type<T>::type>::value> {};
How do you propose to resolve undeclared identifiers that are defined in a different translation unit? C++ has no module concept, but has separate translation as an inheritance from C. A C++ compiler will compile each translation unit by itself, not knowing anything about other translation units at all. (Except that export broke this, which … Read more
This has nothing to do with overriding functions. It has to do with conversions. It really doesn’t have to do with accessibility (i.e “private” or such) directly either. Here is a simpler example struct A { int a; }; struct B : A { }; struct C : B, A { }; // direct A … Read more
This is part of the rules concerning dependent names. Method1 is not a dependent name in the scope of Method2. So the compiler doesn’t look it up in dependent base classes. There two ways to fix that: Using this or specifying the base type. More details on this very recent post or at the C++ … Read more