You can use this-> to make clear that you are referring to a member of the class: void Bar<T>::BarFunc () { std::cout << this->_foo_arg << std::endl; } Alternatively you can also use “using” in the method: void Bar<T>::BarFunc () { using Bar<T>::_foo_arg; // Might not work in g++, IIRC std::cout << _foo_arg << std::endl; } … Read more
I always destroy and create views because as my single page app gets bigger and bigger, keeping unused live views in memory just so that I can re-use them would become difficult to maintain. Here’s a simplified version of a technique that I use to clean-up my Views to avoid memory leaks. I first create … Read more
If you use C++11, you can use static_assert with std::is_base_of for this purpose. For example, #include <type_traits> template<typename T> class YourClass { YourClass() { // Compile-time check static_assert(std::is_base_of<BaseClass, T>::value, “type parameter of this class must derive from BaseClass”); // … } }
You can use subtle and ugly tricks in order to create that kind of templates. Here’s what I would do: Creation of a templated list Macro to define the list I would first create a macro – let’s call it say define_list(type) – that would create all the functions for a list of a given … Read more
This is not how std::make_pair is intended to be used; you are not supposed to explicitly specify the template arguments. The C++11 std::make_pair takes two arguments, of type T&& and U&&, where T and U are template type parameters. Effectively, it looks like this (ignoring the return type): template <typename T, typename U> [return type] … Read more
I strongly recommend the MahApps it’s simply awesome!
You can use the standard library string an its Template class. Having a file foo.txt: $title $subtitle $list And the processing of the file (example.py): from string import Template d = { ‘title’: ‘This is the title’, ‘subtitle’: ‘And this is the subtitle’, ‘list’: ‘\n’.join([‘first’, ‘second’, ‘third’]) } with open(‘foo.txt’, ‘r’) as f: src = … Read more
Well, to be frank, client-side templating is very hot nowadays, but quite a jungle. the most popular are, I believe: pure: It use only js, not his own “syntax” mustache: quite stable and nice I heard. jqote2: extremely fast according to jsperfs jquery templates (deprecated): there are plenty others, but you have to test them … Read more
Just took a look over the mustache docs and they support “inverted sections” in which they state they (inverted sections) will be rendered if the key doesn’t exist, is false, or is an empty list http://mustache.github.io/mustache.5.html#Inverted-Sections {{#value}} value is true {{/value}} {{^value}} value is false {{/value}}
template<class T> class BE{ template<class T> friend class BT; }; Is not allowed because template parameters cannot shadow each other. Nested templates must have different template parameter names. template<typename T> struct foo { template<typename U> friend class bar; }; This means that bar is a friend of foo regardless of bar‘s template arguments. bar<char>, bar<int>, … Read more