array = new int*[_size];
for( unsigned int i = 0; i < _size; i++ )
    array[i] = new int[_size];

you are in fact creating one dimensional array of pointers to other arrays. Main two disadvantages of this approach:

• Initialization can take a while (image really big 2-3 dimensional array, lets say: 16384 x 16384: how many times memory allocation is being performed? 1 + 16384. Quite a lot, right?
• dynamic arrays created like in the code above can not be used as a parameters for memcmp, memcpy, memset & similar functions. the memory allocated is not a continuous memory block.

As I needed a 2-dimensional array that occupies continuous block of memory – I started googling :) I have found a great solution by  David Maisonave (Axter) (code, header). The code above could be rewritten as follows:

Pixel** Initialize2dArray( int size )
{
    Pixel **array2d;
    Pixel *temp;
    array2d = new Pixel*[size];
    temp = new Pixel[size * size];

    for( int i = 0; i < size; i++ )
    {
        array2d[i] = temp;
        temp += size;
    }
    return array2d;
}

void Deinitialize2dArray( Pixel** array2d )
{
    delete [] *array2d;
    delete [] array2d;
}

How does it work? The idea is to put in every ‘cell’ of the array a pointer that will point to a part of the ‘temp’ array. The parts are of the ‘width’ size. So, when you type array[2][3] it actually selects the data that is indexed 2 * width + 3 = exactly what you’re expecting, right? But beware, there is a little difference when using array created in described way and all those mem* functions I wrote at the beginning, instead of writing:

memcpy( array2d, source, sizeof(int) * size * size );

you actually need to write:

memcpy( &array2d[0][0], source, sizeof(int) * size * size );

It is great, right? And, of course, you could try using std::vector (it allocates continuous block of memory – correct me if I am wrong) or Boost Multi Array instead – but if you’re worrying about performance… I think the presented solution is the best.

• you may add “/FORCE:MULTIPLE” in linker options (Project properties –> Linker –> Command Line) – but this does work… partially – it creates proper executable, but in my case I got some assert exception at the very end of executing my app (actually it was when all resources were to be freed – but I didn’t want to investigate it further – app worked, but it is strange to see the exception dialog all the time)
• you may exclude one of the libraries that is causing the problem. Which library? Well, it depends on: what was your project type (Linker –> System –> Subsystem: /SUBSYSTEM:CONSOLE, /SUBSYSTEM:WINDOWS…). In the sample form CUDA SDK, the library that you should get rid of (Linker –> Input –> Ignore Specific Library; remember to write only library’s name, without extension) is: LIBCMTD, in my own project (created from scratch) it is: MSVCRTD for Debug, and LIBCMT for Release. The only advise is to look carefully at what is your linker spitting out, and just ignoring this specific library that makes the whole process to fail (and it is very good idea to have more verbose output: Linker –> General –> Show Progress: /VERBOSE:LIB or even /VERBOSE). In my case the BuildLog.htm (automatically produced by VS) contained following information:

[...]

MSVCRTD.lib(ti_inst.obj) : error LNK2005: "private: __thiscall type_info::type_info(class type_info const &)" (??0type_info@@AAE@ABV0@@Z) already defined in LIBCMT.lib(typinfo.obj)
MSVCRTD.lib(ti_inst.obj) : error LNK2005: "private: class type_info & __thiscall type_info::operator=(class type_info const &)" (??4type_info@@AAEAAV0@ABV0@@Z) already defined in LIBCMT.lib(typinfo.obj)

[...]

Finished searching libraries LINK : warning LNK4098: defaultlib ‘MSVCRTD’ conflicts with use of other libs; use /NODEFAULTLIB:library

[...]

As you see, the problem lies in linking MSVCRTD.lib. Although it is not always so easy. Sometimes different library should be excluded from the process of linking.

It seemed to me, that the problem was fixed. I was wrong. Something bothered me. Why there were no simple solution for this problem? And why the problem was not always with the library the linker had problem with (the one, that it informed about problems with)? And than I started thinking about something I read about how Microsoft C++ compiler / linker works: there are bunch of libraries that are included by default. The libraries are organized in groups (compiled with debug info for debug purposes, etc.), and compilation or linking and mixing libraries with two different worlds may lead to errors. If you right click on your .cu or .cpp file in your project and navigate to “General C++ –> Code Generation” (in case of .cpp file) or “CUDA Build Rule v.2.1.0 –> Hybrid CUDA/C++ Options” (in case of .cu file), you’ll see “Runtime Library” option. And if all your files share the same setting, the problem with linking disappears, and now I am sure, that this is the right solution :) And remember, that this option for all the files must be exactly the same! “Multi-Threaded” and “Multi-Threaded DLL” are NOT the same (the have different linker switches), so just be careful, and pay attention what you change.

I hope it helps someone, because I have wasted a bit of time.

// forward declaration    					//(1)
void functionEx( );    						//(2)
typedef void( *void_function_pointer)(void);			//(3)

class SimpleClass
{
private:
	void (*function_pointer)( );				//(4)
	void_function_pointer func_ptr;

	void SetCallBack( void (*function_pointer)(void) )
	{
		this->function_pointer = function_pointer;	//(5)
	}

public:
	void function( )
	{
		printf("\n");
	}

	void Prepare( )
	{
		SetCallBack( functionEx );
	}

	void Invoke( )
	{
		function_pointer();
	}

};

SimpleClass *externalObject;

void functionEx( )
{
	externalObject->function();				//(6)
}

int _tmain(int argc, _TCHAR* argv[])
{
	externalObject = new SimpleClass();
	externalObject->Prepare();				//(7)
	externalObject->Invoke();				//(8)

	return 0;
}

First three lines (marked with (1), (2) and (3)) are just simple forward declarations of global function and pointer to the function that takes no arguments and does not return anything (’procedure’ in some languages). Declared function pointer is used inside SimpleClass (4) and SetCallBack assigns argument value (function pointer) to variable inside SimpleClass (5). Global function ‘functionEx’ (6) does nothing more than calling ‘function’ from object of type ‘SimpleClass’. Where’s the problem here? It seems everything is simple, right? Right. But it is the simplified version of the code I have after I manually renamed function names. The code I was working on was not object-oriented at all – at the beginning. Let’s imagine, that the name of global function is not ‘functionEx’ but ‘function’. Code does not compile. Ok. Lets use Refactor C++ to rename the name of the global ‘function’ to anything that will be different than the name of the method inside SimpleClass. The problem is, Refactor tries to rename things that shouldn’t be renamed, and skip those, we would like to have renamed. Moving cursor to ‘Prepare’ function, selecting ‘function’ (remember, we do not have any ‘functionEx’ in our code!) makes something strange: refactor tries to rename ‘function’ but… it renames the name of the method inside SimpleClass instead of the global function. And now imagine, that the code is a bit more complex, that there are a couple of files inside the projects – headers and .cpp files… This ‘unwanted’ refactoring makes more harm than good (in this case). You may say, that it is because of the code, that looks the way it does… I do not think so. I would expect refactoring tool to be much more ‘intelligent’, but still it is better to have anything (even not the state-of-the-art refactoring tool) than to be forced to make all editing by hand.

I was very interested if the mentioned earlier Whole Tomato’s Visual Assist X will be intelligent enough to cope with renaming the ‘function’. Well, Visual Assist X provides its own mechanism for renaming (not so well integrated with Visual Studio editor as in case of Refactor for C++) and it is much easier to perform renaming, because Visual Assist X shows what actions it is going to perform (and you may uncheck those, you don’t want to happen). Visual Assist X by default wanted to rename the method inside SimpleClass – just like Refactor for C++. So it seems that there is no perfect solution, and one has to be very careful while refactoring anything that contains any non standard pieces of code. Just be aware that something like the issue I have described above may happen, and that’s it.

Happy coding in 2009 :)

After a while developing apps only using .NET (mainly C#) I felt a need to get a deep dive into C++ programming (DirectX). First impressions? It seems that VS is completely different (much harder) to use if you are C++ developer. There are many things that do not work as good as when using C#. First problem is that Intellisense for C++ is much poorer. You got to deal with .ncb files (sometimes the only solution is to delete .ncb file in your project and then… surprisingly IntelliSense gets back from grave).

Worth noting is that DevXpress (Microsoft partner) released another great plugin for Visual Studio without charging for it: Refactor for C++ (the plugin is mentioned also on MSDN site: http://msdn.microsoft.com/en-us/visualc/bb737896.aspx). It is definitely something you should give a try (and I bet you won’t stop using it). Don’t be fooled by installer – the latest version DOES work with Visual Studio 2008 (and not only 2005 as you could think from what is being displayed during installation). Having Refactor for C++ is much better than not having any opportunity to refactor code, but… there are many things that any Visual C# developer is used to, and think of as a ‘must be’ feature of Visual Studio IDE. The refactorings offered by DevExpress’ product are really simple, do not expect possibility to move function body between header / cpp file, extracting parts of a function to another one does not work as I expected, and even simple renaming caused me some problems. Let’s take under consideration following piece of code:

// forward declaration
void RenamedFunction( );

class SimpleClass
{
public:
    void function( )
    {
        printf("<SimpleClass/>n");
    }
};

SimpleClass *externalObject;

void RenamedFunction( )
{
    externalObject->function();
}

As you can see Function is a global function name, and also a name of the SimpleClass. I had similar situation in my code. I wanted to rename Function, and what happend? Well… Refactor renamed it, but… it also renamed the name of the method (SimpleClass->Function became SimpleClass->NewName). I have fixed function names in several places, and created a new project to test if it is safe to rename functions using Refactor for C++ but I couldn’t get the same behaviour – so maybe it really WAS my fault ;) Well… I have checked it in my project… and yes, it still renames the global function AND method inside SimpleClass… I wonder why this bug does not occur in the sample I have provided above… I’ll try to investigate this issue further on.

Most of the things I am missing in Visual Studio IDE itself and Refactor for C++ are available through great plugin by Whole Tomato Software – Visual Assist X. I am sure, you have heard of its biggest opponent – Resharper from JetBrains, so why should be interested in Visual Assist X? The answer is simple, if you never ever use any other language than C#/VB.NET – you have two options: Visual Assist X or Resharper – they both increase coding speed and make you being less afraid even if there are some complicated refactorings to be made. And if sometimes you use C++ as your development language (especially unmanaged)…Visual Assist X is the only option available.

The last thing that made me mad was… VS seems to ‘lost’ support for .hlsl / fx files (pixel/vertex/geometry shaders written in HLSL / Cg). It is kind of a strange, because I remember that it worked long, long time ago (around August 2005 – Visual Studio 2005 Beta with DirectX SDK from August 2005 as far as I can remember). Why doesn’t it work now? It is hard to say. I don’t even know if it’s an issue of VS2008/2005 or just something was broken inside DirectX SDK (I am currently using November 2008). It is funny how quick one became used to something that was a ‘wow’ feature not so long ago :) I missed syntax highlighting in effect / hlsl files so much, that I started looking for some alternative or plugin for VS or some .xsd file (with definition of shader key words) at least… And I found one – Intellishade.Net. It is great that someone gives for free something I thought Microsoft offers :)

After all this, I am really curious what has been said on one of the PDC 2008 sessions concerning new Visual Studio (I think the title of the session was: “VC10 is the new VC6″). I really hope that there will be enough encouragement from all C++ developers, so that MS creates a lot more convenient and powerful IDE for VC++ developers. There is still need for the good C++ IDE for Windows, and I think it is much behind Visual C#. C++ is not dead, and it seems that it won’t be for a long time.