It makes it easier to generate source code, and also to write code which can be easily extended at a later date. Consider what’s required to add an extra entry to: int a[] = { 1, 2, 3 }; … you have to add the comma to the existing line and add a new line. … Read more
Simple: #include <stdexcept> int compare( int a, int b ) { if ( a < 0 || b < 0 ) { throw std::invalid_argument( “received negative value” ); } } The Standard Library comes with a nice collection of built-in exception objects you can throw. Keep in mind that you should always throw by value … Read more
There are several problems with reflection in C++. It’s a lot of work to add, and the C++ committee is fairly conservative, and don’t spend time on radical new features unless they’re sure it’ll pay off. (A suggestion for adding a module system similar to .NET assemblies has been made, and while I think there’s … Read more
Templates are all about the compiler generating code at compile-time. Virtual functions are all about the run-time system figuring out which function to call at run-time. Once the run-time system figured out it would need to call a templatized virtual function, compilation is all done and the compiler cannot generate the appropriate instance anymore. Therefore … Read more
//***C++11 Style:*** #include <chrono> std::chrono::steady_clock::time_point begin = std::chrono::steady_clock::now(); std::chrono::steady_clock::time_point end = std::chrono::steady_clock::now(); std::cout << “Time difference = ” << std::chrono::duration_cast<std::chrono::microseconds>(end – begin).count() << “[µs]” << std::endl; std::cout << “Time difference = ” << std::chrono::duration_cast<std::chrono::nanoseconds> (end – begin).count() << “[ns]” << std::endl;
What is it? A span<T> is: A very lightweight abstraction of a contiguous sequence of values of type T somewhere in memory. Basically a struct { T * ptr; std::size_t length; } with a bunch of convenience methods. A non-owning type (i.e. a “reference-type” rather than a “value type”): It never allocates nor deallocates anything … Read more
#include <thread> #include <iostream> class bar { public: void foo() { std::cout << “hello from member function” << std::endl; } }; int main() { std::thread t(&bar::foo, bar()); t.join(); } EDIT: Accounting your edit, you have to do it like this: std::thread spawn() { return std::thread(&blub::test, this); } UPDATE: I want to explain some more points, … Read more
vector<T>::const_iterator first = myVec.begin() + 100000; vector<T>::const_iterator last = myVec.begin() + 101000; vector<T> newVec(first, last); It’s an O(N) operation to construct the new vector, but there isn’t really a better way.
Actually, the first one is a bad idea. Use either the second one, or this: struct greater { template<class T> bool operator()(T const &a, T const &b) const { return a > b; } }; std::sort(numbers.begin(), numbers.end(), greater()); That way your code won’t silently break when someone decides numbers should hold long or long long … Read more
This is excellent practice. By creating variables inside loops, you ensure their scope is restricted to inside the loop. It cannot be referenced nor called outside of the loop. This way: If the name of the variable is a bit “generic” (like “i”), there is no risk to mix it with another variable of same … Read more