But it is not in C++ standard.
How can it be solved ?

Very simply with #ifdef + #define.

And we get the following picture:

Check out Here and Here.

There is a little hack to allow this but it needs some investigations.

Create a C++/CLI project in VS2010.

In Project Properties -> VC++ Directories set Include, Lib, Src to VC++ 9.0 directories. (%Program Files(x86)%\Microsoft Visual Studio 9.0\VC\…)

Voila ! Now Reflector shows us references only to mscorlib v2.0 !

You can use any C++0x features supported in C++/CLI too.

The problem:

It was simple and powerful but not perfect.

After you run the program you get:

Unhandled Exception: System.Runtime.InteropServices.SEHException: External component has thrown an exception.
   at System.EventHandler.Invoke(Object sender, EventArgs e)
   at .ModuleUninitializer.SingletonDomainUnload(Object source, EventArgs arguments)

Solution:

Open the file in Hex Editor.

Replace “v4.0.30319″ with “v2.0.50727″ and it works !

Resuming it again:

We can use C++0x & C++/CLI & Visual Studio 2010 !

Update:
I have tweaked “%ProgramFiles(x86)%\MSBuild\Microsoft.Cpp\v4.0\Platforms\Win32\PlatformToolsets” for the new platform I called v100.2
Now it is so easy to compile C++/CLI

“c:\Program Files (x86)\MSBuild\Microsoft.Cpp\v4.0\Platforms\Win32\PlatformToolsets\v100.2\Microsoft.Cpp.Win32.v100.2.props”
“c:\Program Files (x86)\MSBuild\Microsoft.Cpp\v4.0\Platforms\x64\PlatformToolsets\v100.2\Microsoft.Cpp.x64.v100.2.props”

You cannot get a name from the value in a standard way.

Many people invent some tables, maps and so on but here in code this approach is taken much further.

#include <sstream>

enum MyEnum
{
	VALUE1,
	VALUE2,
	VALUE3,
};

char* operator*( MyEnum s )
{
	switch(s)
	{
		case VALUE1: return "VALUE1";
		case VALUE2: return "VALUE2";
		case VALUE3: return "VALUE3";
	}
}

int main()
{
	using namespace std;

	ostringstream s;
	MyEnum r = VALUE3;
	s << "MyEnum is" << *(MyEnum)r;
}

Never ever do it, it confuses the reader.

Provide a normal function name and don’t mess with operators in the wrong place.

int main()
{
  MyClass a(1);
  MyStruct b= { 2 };
}

Some know that you can create object in for loop:

for (int i = 0; ; ) ...


But not many people know that you can also create object in ‘if’ statement :

if (int i = 0) {}
else { cout << i; }


Pay attention that you can use the newly created object in ‘else’ part !

How it works ?
We create object with type ‘int’ , assign to it 0 and then check the result.
What is the result ? It the object itself. As you know int is convertible to bool.

But how it works with more complicated objects ?

class A
{
public:
  A(int) {}
};

if (A a) {}

Here we have incorrect code. How we make it correct ?
We need conversion to boolean from A type. So add it and make working code

class A
{
public:
  A(int) {}

  operator bool() const { return false; }
};

if (A a) {}
else { /* Use a */ }

So the real question “Where is it useful at all ?”.
It is usable in log subsystem or when you need to not compute the expression when it is not needed.
Suppose you want something like this:

WHEN_LOG_ENABLED_FORMAT_STRING() << “a”;
(See Boost.Log )

How you implement this ?
Very simply

#define WHEN_LOG_ENABLED_FORMAT_STRING() \
  if (!logEnabled) {} \
  else StringFormatter()

And if we need to create the object but only when the log is enabled we use the trick from above:

#define WHEN_LOG_ENABLED_FORMAT_STRING() \
  if (!logEnabled) {} \
  else \
  if (StringFormatter sf = StringFormatter()) {} \
  else sf

Again, why is it useful ?
Remember that std::ostream has overload only for std::ostream& and not for reference to const ?
So we must create an object in order to use the std::ostringstream, here we can create it and we don’t need some special _END_ macro.

Any questions ?:)

That’s right. There are no restrictions, no keywords to disallow this.

There are plenty of tricks like private constructor, private destructor, pure virtual destructor and so on.
But none of them works.
Actually it works but not as you wanted it to work.
You can derive, but you cannot create an instance. But these things are very different.

So at last, I give some non working example:
class a
{
private: a(int no_default_constructor) {}
private: virtual ~a() = 0;
};
// You still can derive ! Ha ha
class b : a {}

// But you cannot create an instance, not actually what we wanted
b b1; // Error

There will be something to do so in C++0x. We are waiting..

VKontakte
Facebook
Google Talk

Why is it good ?
You don’t need your crap browser to be open, just ,one in my case, program for chat.
Like Miranda IM

If you are asked which container class should I use, the most common answer will be try std::vector.

The correct answer is in fact a question, what do you want from the container to do.

Why is this so important ? std::vector fits almost in all cases.

The key word is ‘almost’.

What does std::vector provide us ?

No O(1) insertion but continuous memory allocation. Do we need this ??

If you check your code, you can see that in most cases you just need a list of items without carrying if they are allocated on the continuous memory space.

It is useful only for buffer to be passed to C code or to be written as-is to the file.

So, obviously the number one candidate is std::list and not std::vector!

It is true to say, premature optimization is evil, but in this case it is not an optimization it is a logical problem, you use the incorrect tool.

The same problem exists in .Net or Java, most people choose List<T> or ArrayList without thinking at all, while the usage doesn’t involve random access.

Actually the problem in .Net or Java is not so serious since memory allocation is very fast but still it has a logical problem.

Let’s take a simple example:

class DelayedInitialization : boost::noncopyable
{
public:
	DelayedInitialization(int i) : i(i) {}

	int I() const { return i; }

private:
	int i;
};

class Some
{
public:
	Some(int i)
		: d(i) // check i > 0
	{
	}

private:
	DelayedInitialization d;
};

How do we add a check ?

The simplest solution is to use a pointer. Of course we want RAII so we use one of smart pointers written for us.

The best choice here is to use boost::scoped_ptr. Neither std::auto_ptr and absolutely not boost::shared_ptr.

* std::auto_ptr gives much more power than we need. We don’t want accidentally transfer ownership.

* boost::shared_ptr gives us reference count which is useless in our case, moreover it involves synchronization penalty where we don’t need it.

The boost::scoped_ptr has a minimal set of features and the minimum required power.

class DelayedInitialization : boost::noncopyable
{
public:
	DelayedInitialization(int i) : i(i) {}

	int I() const { return i; }

private:
	int i;
};

class Some
{
public:
	Some(int i)
	{
		if(i <= 0)
			throw std::exception();

		d.reset(new DelayedInitialization(i));
	}

private:
	boost::scoped_ptr<DelayedInitialization> d;
};

It is nice but we evolve here memory allocation instead of using variable on the stack.

Another possible solution is to add a function and a dummy variable used for checking, almost perfect:

class DelayedInitialization : boost::noncopyable
{
public:
	DelayedInitialization(int i) : i(i) {}

	int I() const { return i; }

private:
	int i;
};

class Some
{
public:
	Some(int i)
		: checker(check(i))
		, d(i)
	{
	}

private:
	bool check(int i)
	{
		if(i <= 0)
			throw std::exception();

		return true;
	}

	bool checker;
        DelayedInitialization d;
};

While this solves the given problem, this doesn’t solve the problem where Some has a base class and wants to add some checks before continuing.

It can be achieved with a slightly modified check method:

class Base
{
public:
	Base(int i)
	{
	}
};

class Some : public Base
{
public:
	Some(int i)
		: Base(checkI(i))
		, d(i)
	{
	}

private:
	int checkI(int i)
	{
		if(i <= 0)
			throw std::exception();

		return i;
	}

	DelayedInitialization d;
};

Actually this is very neat solution and no additional member is needed !

Now take a real world problem: How to initialize the member in the constructor body rather than in initialization list without memory allocation ?

In short we want the following constructor:

Some(int i)
{
	std::cout << "Some code\n";

	// Magic constructor call
	d.__constructor(i);
}

How do we achieve this ?
Simple enough.
1. Allocate enough stack size for the needed object, also make the stack allocation aligned.

boost::aligned_storage solves this problem. 2. Call constructor and destructor manually.

Use placement new and destructor call.

class DelayedInitialization : boost::noncopyable
{
public:
	DelayedInitialization(int i) : i(i)
	{
		std::cout << "DelayedInitialization. i =  "
			<< i << std::endl;
	}

	int I() const { return i; }

private:
	int i;
};

class Some
{
public:
	Some(int i)
	{
		std::cout << "Some code\n";

		// Magic constructor
		::new(d.address()) DelayedInitialization(i);
	}

	~Some()
	{
		// Don't forget for destructor
		static_cast<DelayedInitialization*>(
				d.address())->~DelayedInitialization();
	}

private:
	boost::aligned_storage<sizeof(DelayedInitialization)> d;
};

Now we got what we need.
No unneeded memory allocation at all !
No run-time penalty if the object has to remain uninitialized. (Actually we need a small boolean to check if the object was initialized or not).

A small helper class and we are set:

class DelayedInitialization : boost::noncopyable
{
public:
	DelayedInitialization(int i) : i(i)
	{
		std::cout << "DelayedInitialization. i = "
				<< i << std::endl;
	}

	int I() const { return i; }

private:
	int i;
};

template<typename T>
class stack_allocation_ptr
{
public:
	stack_allocation_ptr()
		: initialized(false)
	{
	}

	~stack_allocation_ptr()
	{
		if (initialized)
			static_cast<T*gt;(d.address())->~T();
	}

	// We know nothing about underlying type
	// Provide all possible function overloads
	void reset()
	{
		if (initialized)
			throw std::exception();

		::new(d.address()) T();
	}

	template<typename P0>
	void reset(P0 p0)
	{
		if (initialized)
			throw std::exception();

		::new(d.address()) T(p0);
		initialized = true;
	}

	T* operator->()
	{
		return &d;
	}

	T const* operator->() const
	{
		return &d;
	}

private:
	bool initialized;
	boost::aligned_storage<sizeof(T)> d;
};

class Some
{
public:
	Some(int i)
	{
		std::cout << "Some code\n";

		// Magic constructor
		d.reset(i);
	}

private:
	stack_allocation_ptr<DelayedInitialization> d;
};

We have two problems here.
1. We must forward all arguments to constructor. (The forwarding problem)

This problem is not discussed now.

2. We may want to remove initialized member.

It is easy enough to do:)

Conclusion: C++ has better supported a regular initialization instead of two initialization forms.

One likes XCommander and other likes YCommander.

By the word Commander I mean some program with dual (or more) panel interface. Since most “Explorer”s has only one panel , and many see this it as unpractical , there are Commanders programs.

The most known for Windows is Total Commander (Windows Commander in the past) but as many others it costs money.

The other disadvantage it has no x64 build and probably will never get it.

So what you do in x64 ??

You need freeware commander with x64 build.
Double Commander has all needed features.
It is freeware, can work both on Linux and Windows, has both 32 and 64bit builds and the nicest part,
it supports Total Commander plugins too !

After trying freeCommander, muCommander, UnrealCommander and others trying to find an alternative to the perfect TotalCommander, Double Commander is the best alternative for today.

It is your choice to use free programs or to pay money

Now the question, what happens if SVN server is completely destroyed ?
The good answer can be that it is restored from backup. But what if you don’t have a backup or if you have only nightly backup without several last revisions ?
Even if you have latest SVN working copy you cannot restore entire history because SVN doesn’t stores the entire log in the repository.

But if you use Git SVN you can restore SVN repository without any problems because Git stores all SVN revisions !! Wooha!

Conclusions:
1. Backup your SVN server for every (!) committed revision. (otherwise you can lose history).
2. If you cannot do the first use source control which stores all SVN revisions so you always have backup.