Posts Tagged ‘bitbucket

29
Jul
14

UnitC++

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.

 

Continue reading ‘UnitC++’

Advertisements
08
Oct
13

C++ Digraphs

This is not as you might think, an article about implementing directed graphs in C++. The digraphs I am writing about are sequences of characters which act as a stand in for other characters. Digraphs and trigraphs exist in many languages, but I will be focusing on C++. The difference between digraphs and trigraphs is simple the number of characters, a digraph is 2 characters and a trigraph is 3 characters.

Digraphs are part of the language because in the past special characters were hard to input. This was generally because they were not on the keyboard, but in a few cases, they were not even in the code page!

So what use is this now, when modern keyboards have all the symbols we could want and we can use different encodings in source files?

Here is a screenshot of the C++ standard where it defines the allowed digraphs.

Digraphs in C++ Standard

C++ standard digraphs

The first column are backwards compatible digraphs for C. The next two columns are rather interesting.

For example. If you write the word or in a C++ source file, the compiler will replace that with ||. This means that the following code compiles and works.

//=============================================================================
int main() {
  bool a = false;
  bool b = true;
  std::cout << "a or b == " << (a or b) << std::endl;
  return 0;
}

Not only will this work for built in types, this works for user defined operators too. This is because the compiler simply substitutes the symbols.

Here is an example class and calling code which uses all the C++ digraphs.

Class

This is just a stub class which defines a lot of operators which do nothing.

//=============================================================================
class Example {
public:

  //===========================================================================
  // logic operators
  bool operator&&(const Example& t) {
    return true;
  }
  
  bool operator||(const Example& t) {
    return true;
  }
  
  bool operator!() {
    return true;
  }
  
  //===========================================================================
  // bitwise operators
  bool operator&(const Example& t) {
    return true;
  }
  
  bool operator|(const Example& t) {
    return true;
  }
  
  bool operator^(const Example& t) {
    return true;
  }
  
  bool operator~() {
    return true;
  }
  
  //===========================================================================
  // logic equals operators
  Example operator&=(const Example& t) {
    return t;
  }
  
  Example operator|=(const Example& t) {
    return t;
  }
  
  Example operator^=(const Example& t) {
    return t;
  }
  
  Example operator!=(const Example& t) {
    return t;
  }
  
};

Calling Code

//=============================================================================
int main() {
  bool a = true;
  bool b = true;
  if (a and b) {
    cout << "\"and\" is an operator." << endl;
  }
  if (false or b) {
    cout << "\"or\" is also an operator." << endl;
  }
  if (not false) {
    cout << "\"not\" is also an operator." << endl;
  }

  Example t_1, t_2;
  if (t_1 and t_2) {
    cout << "\"and\" even works for classes" << endl;
  }
  
  if (t_1 or t_2) {
    cout << "\"or\" even works for classes" << endl;
  }
  
  if (not t_1) {
    cout << "\"and\" even works for classes" << endl;
  }
  
  if (t_1 bitand t_2) {
    cout << "\"bitand\" also works for classes" << endl;
  }
  
  if (t_1 bitor t_2) {
    cout << "\"bitor\" even works for classes" << endl;
  }
  
  if (compl t_1) {
    cout << "\"compl\" even works for classes" << endl;
  }
  
  if (t_1 xor t_2) {
    cout << "\"xor\" even works for classes" << endl;
  }
  
  t_1 and_eq t_2;
  cout << "\"and_eq\" even works for classes" << endl;
  
  t_1 or_eq t_2;
  cout << "\"or_eq\" even works for classes" << endl;
  
  t_1 xor_eq t_2;
  cout << "\"xor_eq\" even works for classes" << endl;

  return 0;
}

This gives the output;

"and" is an operator.
"or" is also an operator.
"not" is also an operator.
"and" even works for classes
"or" even works for classes
"and" even works for classes
"bitand" also works for classes
"bitor" even works for classes
"compl" even works for classes
"xor" even works for classes
"and_eq" even works for classes
"or_eq" even works for classes
"xor_eq" even works for classes

This file can be found here.

This is an interesting feature, but is it useful?

I think it is, I think that the code;

if (not fail and ok) {
  // ...
}

Is more readable than;

if (!fail && ok) {
  // ...
}

However just because these are defined in the standard does not mean they can be used. These are largely considered a legacy part of the standard and there is limited support for it.

In particular Microsoft’s C++ compiler will not compile it. Both clang and g++ will compile it however, so if you are compiling using either of these you can use this nice feature.

Thanks for reading.

25
Mar
13

C++ Sandbox

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.

Arrays

In this file I was playing around with C style arrays, slightly old and a bit dated to be honest.

Comparisons

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.

ConstPointer

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.

Constness

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.

CopyReference

Trying to copy a reference without using the copy constructor or assignment operator.

DivideByZero

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.

ExclusiveOr

This was for checking the results of using xor on integers.

Lambda

This was testing the newly added lambda functions, but changed to using standard template library algorithms.

MustOverride

This was playing around with pure virtual functions with implementations. So you can call them using Base::function() in the derived class.

Mutable

Testing using a mutable member for data caching. This was the basis for the blog post mutable and data caching.

Operators

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.

  (*f).operator();
  f->operator();

But these will return a function pointer to operator(), they won’t call it.

Polygons

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.

SelfDeleting

Trying to make an executable to delete itself, unsurprisingly this doesn’t work.

SpareMemory

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.

StructClass

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.

VariadicPointerOffset

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,

Windows

Unimplemented test for SetEvent() in windows.h.

get_env

Made to test getenv from cstdlib for getting environmental variables.

hashes

Using C preprocessor magic to join together variable names.

number_of_coins

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.

stack_overflow_virtual

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.

upper

My thoughts about the answer to this stackoverflow question being wrong, and my idea for a better way.

As always thanks for reading.

17
Sep
12

I’m Back, and This Time There’s Versioning!

It has been a while! Sorry about that but I’ve been on holiday and moving etc, but now I’m back and a lot has changed since I last posted. I have started using distributed version control with git and mercurial via GitHub and BitBucket. This means that you don’t have to just look at my code on Box with it’s limited syntax editing and no versioning. Now you can see exactly what I’ve been up to! Continue reading ‘I’m Back, and This Time There’s Versioning!’