It is because name lookup stops if it finds a name in one of your bases. It won’t look beyond in other bases. The function in B shadows the function in A. You have to re-declare the function of A in the scope of B, so that both functions are visible from within B and … Read more
You can use any/all of the following to create a std::string from a single character: std::string s(1, c); std::cout << s << std::endl; std::string s{c}; std::cout << s << std::endl; std::string s; s.push_back(c); std::cout << s << std::endl;
In C++14, you can mark a function as deprecated using the [[deprecated]] attribute (see section 7.6.5 [dcl.attr.deprecated]). The attribute-token deprecated can be used to mark names and entities whose use is still allowed, but is discouraged for some reason. For example, the following function foo is deprecated: [[deprecated]] void foo(int); It is possible to provide … Read more
This is the definitive article on “const correctness”: https://isocpp.org/wiki/faq/const-correctness. In a nutshell, using const is good practice because… It protects you from accidentally changing variables that aren’t intended be changed, It protects you from making accidental variable assignments. For instance, you are protected from if( x = y ) // whoops, meant if( x == … Read more
It defines a pointer-to-function type. The functions return void, and the argument list is unspecified because the question is (currently, but possibly erroneously) tagged C; if it were tagged C++, then the function would take no arguments at all. To make it a function that takes no arguments (in C), you’d use: typedef void (*MCB)(void); … Read more
When not specified, C++ is unmanaged C++, compiled to machine code. In unmanaged C++ you must manage memory allocation manually. Managed C++ is a language invented by Microsoft, that compiles to bytecode run by the .NET Framework. It uses mostly the same syntax as C++ (hence the name) but is compiled in the same way … Read more
You can use the preprocessor “stringify” # to do what you want: #include <stdio.h> #define PRINTER(name) printer(#name, (name)) void printer(char *name, int value) { printf(“name: %s\tvalue: %d\n”, name, value); } int main (int argc, char* argv[]) { int foo = 0; int bar = 1; PRINTER(foo); PRINTER(bar); return 0; } name: foo value: 0 name: … Read more
http://en.cppreference.com/w/cpp/atomic/memory_order has a good example at the bottom that only works with memory_order_seq_cst. Essentially memory_order_acq_rel provides read and write orderings relative to the atomic variable, while memory_order_seq_cst provides read and write ordering globally. That is, the sequentially consistent operations are visible in the same order across all threads. The example boils down to this: bool … Read more
According to Herb Sutter in this article it was “partly an oversight”. The article contains a nice implementation, and makes a strong case for using it: template<typename T, typename …Args> std::unique_ptr<T> make_unique( Args&& …args ) { return std::unique_ptr<T>( new T( std::forward<Args>(args)… ) ); } Update: The original update has been updated and the emphasis has … Read more
I’ve been making some objects using the pimpl idiom, but I’m not sure whether to used shared_ptr or unique_ptr. Definitely unique_ptr or scoped_ptr. Pimpl is not a pattern, but an idiom, which deals with compile-time dependency and binary compatibility. It should not affect the semantics of the objects, especially with regard to its copying behavior. … Read more