The new VS’2013 may be a bit buggy …

In one hand I would say that moving from the old VS’2008 to the new VS’2013 was really fine, because even for a low-level programmer like me (in the project I’m working for, I only use C and C++) the editor’s improvements are really great !
But in another hand as in every software, there is still some bug. I only worked 2 or 3 days with VS’13 but I found 2 bug I reported through the MS Connect portal.
1) The C compiler has a terrible bug and I think that bug is a major issue, because it prevent the build of a tons of good C99 open source code.
for the VS’13 C compiler the following code is wrong and it report the following error:

typedef struct { int j; } test_t;

int f(test_t **p_pool, int i)
{
    if (i <= 0)
        return -1;

    test_t *pool;   
    *p_pool = pool;

    return i;
}

and the error is : 'test_t' : illegal use of this type as an expression

in fact, it looks like the compiler fails to interpret test_t as a type if the if-then statement body before isn’t surrounded by a some {}, for any other basic type, I mean int, char etc…. there is no problem but with all defined type containing “_t” (size_t, prtrdiff_t, uint8_t, etc….) it fails !

A workaround if to rewrite the code as:

typedef struct { int j; } test_t;

int f(test_t **p_pool, int i)
{
    if (i <= 0) {
        return -1;
    }

    test_t *pool;   
    *p_pool = pool;

    return i;
}

But it’s a pain to do that on a huge C/C99 code base.

Updated 2014 April 29th: An answer from MS dev team say that a fix will be available with the next update ... Good to hear!

2) the project property page has been improved with several new option, but switching from Debug to Release configuration directly from the property page may be disappointing, see below what’s may happen when you are doing a that.

Step to reproduce:

• open a C/C++ project configuration property pages


• switch the Configuration (Debug to Release or vice-versa)


• now select another entry in the property tree and look. Below for example I was initially in Release / on C/C++->Preprocessor, I first switched to Debug and clicked on Language.

Hopefully if you switch-back or if you close the pages and re-open then directly with “Debug” Configuration, the option will be back !

The worst optimization I ever made….

As a programmer I often try to simplify the code and reduce the number of operation, but few days ago I made a big mistake.

In a video processing system, I replaced the following line, we use for each frame to compute its Presentation TimeStamp (a.k.a its PTS):

curr_pts = first_pts + nb_frame * duration;

by a simple addition

curr_pts += duration;
and curr_pts was initialized with first_pts.

Now let say that all those values are floating point number (double or float).
In the floating point number world, those 2 code aren’t really equivalent due to the error accumulation.

That problem is well known and a solution to minimize the error is the Kahan’s summation algorithm.

Take a look here on Ideone at a small test code I made to demonstrate it…..

But basically if we compute the delta between the 1st version and the 2nd version, we get 3.14042e-05 and with the Kahan’s algorithm we get only a delta of 1.74623e-09.

A big mistake and a big reminder that floating point computation aren’t so easy ….

Class/Struct definition local to a function.

You may know or not that defining a class or struct inside a function is possible but you may not be aware of all the issue you will meet when using that with the old C++98.
First thing, if you are using C++11 you can pass away, because in all case that feature will be correctly handle by recent compiler and debugger.
Now if your are still using a C++98 compiler or an old GCC, stay here and read the following:)

Definition in a function

In most case the following code will be Ok.

int function() { 
   typedef struct myStruct { 
       int num; 
       myStruct (int n): num(n){} 
       myStruct(const myStruct& ro):num(ro.num){} 
    } mystruct_t; 

  mystruct_t t(2);

  return t.num;
} 

But want will happened if you try to use that struct with an STL’s container, like vector, deque, etc….. Example

int function() { 
   typedef struct myStruct { 
       int num; 
       myStruct (int n): num(n){} 
       myStruct(const myStruct& ro):num(ro.num){} 
    } mystruct_t; 

  std::deque<mystruct_t> dq(10, mystruct_t(2));
  
   return dq[0].num;
} 

In fact here we have 2 different scenario:

1. you are using GCC and it will not compile, because it’s not a C++98 compliant code
2. you are using VC++2008 and it will compile, but you will meet weird debugger behavior on that piece of code.

Explanation

In C++98, you cannot use local class or struct with template type. This restriction is part of the standard. The reasoning was originally that local structures don't really have a names and thus it would be impossible to instantiate a template with them.

So as said if VC++2008 allow that code to compile, you will not be able to see what you have in your deque… Like in the snapshot below.

My conclusion

Try to avoid that kind of code until you get the new C++11, because the portability across platform is not guarantee by the standard and that debugging and maintaining them is really hard. Define your class or struct outside of the function.

Step-by-step through C++ Template

As some of my teammate always complain that template-based code are really hard to understand and that they would prefer coding without, I will try here to explain how it works and propose some complexity-growing example.

NOTE1: that post will be periodically update....
NOTE2: that post/tutorial is design in a way to can do all exercise without local compiler, I wrote a solution using Ideone, so create your account and write your own solution for all exercise.

A first look at the template syntax <> and their usage:

We using template and/or writing template you "can" meet the < CONTENT > syntax
Where Content can be:

• class T / typename T
• A data type, which maps to T
• An integral specification
• An integral constant/pointer/reference which maps to specification mentioned above.

1st Example

Imagine we want a function to multiply by 2 an integer

int mulByTwo(int v) { return v*2;}

And we can write int I = mulByTwo(2);

Now we also want mulByTwo but for float and we avoid code duplication.
Question: Write only one function MulByTwo to deal with:

int I = mulByTwo(2);
double D = mulByTwo(2.0);

Solution: here

Observe basic/simple "type deduction" error message

Now using the 1st example, what's happen if you call:
string S = mulByTwo("blahblah....");

Now build a function Sum, range-based to deal with iterator and pointer of any kind !

Tips: an iterator is just a simple base class implementing some operator like: ++,--,+=,-=,*, ->, [], etc...

Add the end with only 1 function, you should be able to execute:

int main() {
    int testArray[5] = {0,1,2,3,4};
    vector v = {0, 1, 2, 3, 4};
    vector s = {"hello", " ", "world"};
  
    cout << Sum(v.begin(), v.end()), cout << endl;
    cout << Sum(testArray, testArray + sizeof(testArray)/sizeof(testArray[0])), cout << endl;
    cout << Sum(s.begin(), s.end()), cout << endl;
  
    return 0;
}

Solution: here

How to use integral template

as for type deduction, the compiler will prepare everything at the compilation time.

Example: template&ltint&gt struct example { static double value = N * 2.0; }
If we write: cout << example&lt5&gt::value;

Exercise: Use that to compute factoriel&lt5&gt at compile time
Solution: here.

------ > followings section are under construction <------------------------ br="">

Solving ambiguity / Explicit Template Arg Specification

 

Default template  argument

Template and Specialization

char ** conversion to string

First, I would say it was a long time without posting anything, but I’m a bit in trouble in my personal life. And finally today as I was working on a command line implementation I realize that it’s a good practice to log (wherever you want …) the command line argument used to run a command line executable.

And as I was writing the code to do that, I was thinking that some developer may have create some complex code with loop display the command line argument that we have in argv. But in fact if you can use C++ STL and also the powerful BOOST Framework, it use only 2 lines of code (or even less).

So let start, first cmd line arguments are from the main function point of view an array of char*. So the 1st thing to do convert that in the C++ world.

vector<string> cmdline(argv+1, argv+argc);

Ok now we have STL object we all know on which we can easily iterate to concatenate each string and insert a delimiter (a simple space “ ”). But instead of using a complex loop I prefer using an efficient BOOST string algorithm call join.

#include "boost/algorithm/string.hpp"

….

string cl = boost::algorithm::join(cmdline, " ")

now you can dump the argument passed to your command line with a cout or any logging system you want.

And have a nice weekend.

C++: How to handle exception in CTOR

Yesterday I was reading that thread on Linkedin, and I realized once again that the exception handling in/or around a constructor(CTOR) is still an obscure topic as only one commenter mentioned the correct try-catch form for CTOR that can handle every exception even those coming from the initialization list.
The main problem when an exception occur during a CTOR is what have we to do for cleaning memory allocated on the heap.
To summarize the easiest way to handle exception, I produced the following example.

The output will be (I added some comments:

• object_t CTOR ==> object_t allocation in our initializer list put in a smart_ptr (1)
•  test_t CTOR ==> here we enter in the test_t CTOR Impl
• object_t CTOR ==> we allocated a new object (2)
• … here we have thrown the exception
• object_t DTOR ==> the smart pointer object is on the stack, so the stack unwinding run and the memory allocation (1) is cleaned
• here we handle our dynamic allocation ==> we are now in the CTOR catch section, as we have correctly ordered our data member we can check `if (ptr != nullptr)` and delete it if needed.
• object_t DTOR ==> now the memory allocation (2) is released.
• exception just to test... ==> as we have and should always RETHROW the exception, we catch it!

Conclusion: If we based all our class on that model, there is no reason anymore to fear about memory leaks.

Use Beyond Compare as SVN diff tool under Linux

Today a quick note on that topic as I extended my own configuration with that tricks. BeyondCompare is a well known tool to compare and merge different  version file.

I used it a lot combined with ToirtoiseSVN, but as I worked more and more under linux using Remote Workstation, I would also use it. But I mainly work on remote workstation using a putty prompt. I will not describe here how to setup bcompare on a linux workstation, but it’s the 1st thing todo.

Next you have to follow my previous post to redirect the all X application to your local (I mean Windows 7 in my case) X11 server.

Now when you run “svn diff” on a file, you expect to use bcompare. To achieve that goal, follow me step by step.

cd ~

touch .subversion/bcompare_svn.sh

nano .subversion/bcompare_svn.sh

COPY/PASTE the folllowing in that script:

#!/bin/bash

/usr/bin/bcompare $6 $7 &

exit 0

Set execution permission

chmod 755 .subversion/bcompare_svn.sh

nano .subversion/config

Add that line just after “# diff-cmd = diff_program (diff, gdiff, etc.)”

diff-cmd=/home/YOURFOLDER/.subversion/bcompare_svn.sh

And done !

Now at each svn diff  command you start, BeyondCompare will start and display on the own PC.