Archive for the 'C++11' Category
This post is an introduction to a library I have written, UnitC++.
UnitC++ is a modern, light weight, header-only c++ library for making unit testing easy. The intention of this library is to make it really easy to test c++ code in a portable way.
Great article by Bartosz Milewski. I’m always interested in applying different paradigms to C++. Here is my attempt at this.
“Data structures in functional languages are immutable.”
What?! How can you write programs if you can’t mutate data? To an imperative programmer this sounds like anathema. “Are you telling me that I can’t change a value stored in a vector, delete a node in a tree, or push an element on a stack?” Well, yes and no. It’s all a matter of interpretation. When you give me a list and I give you back the same list with one more element, have I modified it or have I constructed a brand new list with the same elements plus one more?
Why would you care? Actually, you might care if you are still holding on to your original list. Has that list changed? In a functional language, the original data structure will remain unmodified! The version from before the modification persists — hence such data structures are called persistent (it has…
View original post 4,199 more words
This is just a short post to tell you about my C++ sandbox. This is my area for trying out ideas (such as using mutable for caching) or testing C++ 11 features.
This is stored as a mercurial repository on bitbucket here. Please feel free to have a look or add to it if you have something you want to try out. I often use this to test answers to stackoverflow questions. A few of them have generated blog posts here as well.
The rest of this post is the current contents of the repository with a brief description of what I was trying to do with each file.
In this file I was playing around with C style arrays, slightly old and a bit dated to be honest.
This may be a future post here. It defines a templatised base class for comparable class (using the curiously recurring template pattern . It means that if you inherit from this class and define one compare function, you get all 6 comparison operators.
Testing out what you can do with const pointers. With a const Class* const you can only call const methods, with a Class* const you can call anything (this keeps the pointer const not what it points at) and with a Class* you can call anything.
Found an unusual bug and tested it here. If you have a reference (or a pointer) as a member of your class, in a const function you can call non-const functions on the member. This is because it doesn’t change the reference (or pointer) which the class keeps, what it does is change is the object it references.
Trying to copy a reference without using the copy constructor or assignment operator.
I wondered what compiler errors/warnings you get from dividing by zero?
It turns out (in g++) that it will not give errors at all. It will warn you if you divide by a literal zero or a const zero, but not a variable with value zero.
This was for checking the results of using xor on integers.
This was testing the newly added lambda functions, but changed to using standard template library algorithms.
This was playing around with pure virtual functions with implementations. So you can call them using Base::function() in the derived class.
Testing using a mutable member for data caching. This was the basis for the blog post mutable and data caching.
Testing calling operator() on pointer. Here is the calling code.
Foo* f = new Foo(); (*f)(); (*f).operator()(); f->operator()(); delete f;
A common mistake doing this is to leave off the final brackets so.
But these will return a function pointer to operator(), they won’t call it.
Archetypal polygon example for inheritance. A base polygon, a derived rectangle and triangle. Not great as you use a width and height for the polygon but not all polygons have it. Also I prepended all the classes with the letter C and allocated the instances as pointers to the base class.
Trying to make an executable to delete itself, unsurprisingly this doesn’t work.
Something picked up from a dirty programming trick called the programming antihero (if you haven’t read that article I can’t recommend it enough!). In this there was a game programmer who reserved 2Mb of memory to lose later when memory was tight. I was testing to see how this worked by reserving some memory and checking memory usage. It is had to see the exact memory usage from this sort of thing due to differences in types of memory (i.e. private bytes/working set…) but it certainly took some memory.
Testing out the differences between structs and classes in C++. I found that apart from private/public as default there is no difference! This includes if you declare class T in a template, you can still use a struct.
UserDefinedLiterals and UserDefinedLiteralsBinary
Trying to use C++ 11 user defined literals to be able to use syntax like this:
Binary two = 10_b;
I was following a good guide from here.
Quite a complicated file. I was trying to use variadic templates to access private methods of a class. Hopefully not of any practical use (it breaks encapsulation and is extremely fragile) but an interesting idea to try,
Unimplemented test for SetEvent() in windows.h.
Made to test getenv from cstdlib for getting environmental variables.
Using C preprocessor magic to join together variable names.
Given an amount in cents (American currency as it was taken from an answer on stackoverflow) find the number of ways you can make it from quarters, dimes, nickles and pennies. This was taken from this answer.
I didn’t think the reply to this question would compile so I tried it out. I realised you can override private virtual functions but not call them.
My thoughts about the answer to this stackoverflow question being wrong, and my idea for a better way.
As always thanks for reading.
I don’t think this is widely known but auto was already a keyword in C++ and also C. Prior to it’s removal in C++09 it was used as a storage duration indicator. What this means is that it tells the compiler how long the storage for the variable needs to last for. The auto keyword is the default and means that the storage is available until the end of the block in which the variable is created. The fact that this is the default behaviour for C++ and it’s infrequent use lead to it being removed from the standard. As Bjarne Stroustrup writes
Several committee members trawled through millions of lines of code finding only a handful of uses — and most of those were in test suites or appeared to be bugs
So onto the new auto. Continue reading ‘Auto’
This blog post is going to be about the c++ keyword mutable, it is also going to go into using mutable for data caching. To motivate this I am going to give an example from python. If I have a class with a property which is expensive to compute I want to cache it and only recalculate it when necessary. Continue reading ‘Mutable and Data Caching’