cli – Code musings in C#

C, C++ and C++/CLI cheat sheet

No explanation of the basic concepts, just a memory help when you don’t use C/C++ frequently, or if you’re a beginner with some bases.

First question: why pointers? Answers: because functions arguments are passed by value in C and C++. Because arrays and strings are crazy in C.

How to read pointers

Here is a handy way of remembering how pointers syntax works.

In variable declaration

Go from the right to the left of the declaration, from the innermost parenthesis, going back to the right when hitting “)”

Read the name of the declaration
* is “a pointer to”
[] is “an array of”
() is “a function returning”
Finally, read the type

int *p[]; reads “p is an array of pointers to int”.
int *(*foo())(); reads “foo is a function returning a pointer to a function returning a pointer to int”.

In variable usage

Variable usage reads from left to right.

Determine “get” (read variable) or “set” (write variable)
* is “the value pointed to by”
& is “the address of”
[i] is “the element at position i”
Read the variable name

*p = 5;  reads “set the value pointed to by p”.
x = &i;  reads “get the address of i”.
printf("%i", *foo[0]);  reads “get the value pointed to by the element at position 0 of foo”.

C pointers

Manipulating a variable through a pointer is called dereferencing. It is used through an indirection expression.
Manipulating pointers through variables is called decaying.

Given an integer:

int i = 42;

1	int i = 42;

Create an pointer:

int* p = &i; // or int *p = &i; // preferred syntax

1
2
3

int* p = &i;
// or
int *p = &i; // preferred syntax
Get the memory location of the variable:

printf("%i", p); // or printf("%i", &i); // or pritf("%i", &*p); // get the address of the value pointed to by p

1
2
3
4
5

printf("%i", p);
// or
printf("%i", &i);
// or
pritf("%i", &*p); // get the address of the value pointed to by p
Get the value of the variable:

printf("%i", i); // or printf("%i", *p); // or printf("%i", *&*&*&*p); // if you want to be stupid

1
2
3
4
5

printf("%i", i);
// or
printf("%i", *p);
// or
printf("%i", *&*&*&*p); // if you want to be stupid
Set the value of the variable:

i = 42; // or *p = 42;

1
2
3

i = 42;
// or
*p = 42;
Setting a pointer to null allows to assign it to a variable later:

int *p = NULL; if (p) { // use *p }

1
2
3
4

int *p = NULL;
if (p) {
// use *p
}

C arrays

Arrays mostly can’t be manipulated directly, but rather through pointers.
The variable array is, for most intents and purposes, a pointer to the first element of the array (until it’s incremented).

Given an array of integers:

int array[] = { 45, 67, 89 };

1	int array[] = { 45, 67, 89 };

This doesn’t really creates an array. It creates 3 integers side-by-side, and stores the memory location of the first one.
array == &array == &array[0]
When you pass an array as an argument to a function, you really pass a pointer to the array’s first element, because the array decays to a pointer.
Incrementing a pointer to an array really moves the pointer to the next element of the array (the pointer is incremented by the size of the type of the pointer).

array++; // now the "array" pointer points to the second element.

1

array++; // now the "array" pointer points to the second element.
The subscript operator (the [] in array[0]) has nothing to do with arrays themselves, you can also use it on a pointer:

int *ar_p = array; printf("%i", ar_p[0]); // outputs the memory location of the first element printf("%i", *ar_p[0]); // outputs the value of the first element

1
2
3

int *ar_p = array;
printf("%i", ar_p[0]); // outputs the memory location of the first element
printf("%i", *ar_p[0]); // outputs the value of the first element

C structures

Given a structure:

struct foo {
  char name[10];
  int result;
};

struct foo f; // note you have to specify "struct" in the declaration

struct foo {

char name[10];

int result;

};

struct foo f; // note you have to specify "struct" in the declaration

Accessing members of the structure through the variable:

f.result = 42; printf("%i", f.result); // outputs "42"

1
2

f.result = 42;
printf("%i", f.result); // outputs "42"
Accessing the members through a pointer:

struct foo *p = f; (*p).result = 42; // or p->result = 42; // using a pointer-to-member operator

1
2
3
4

struct foo *p = f;
(*p).result = 42;
// or
p->result = 42; // using a pointer-to-member operator

C++ references

C++ is much less in love with pointers than C, and prefers using reference variables. They are mostly used in the same way as pointers, but their address can’t change (they always points to the same variable).
The main usage of a reference variable is for function parameters, to pass the variables by reference (by default it’s by value), which allows to not use pointers.

Given an integer:

int i = 42;

1	int i = 42;

Create a reference to a variable with int &r = i; ; this is called binding a reference to an object
You do not need to dereference a reference to access the variable’s value:

i = 42; // or int &r = i; r = 42; // should generate about the same machine code as int *p = i; *p = 42;

1
2
3
4
5
6
7
8

i = 42;
// or
int &r = i;
r = 42;

// should generate about the same machine code as
int *p = i;
*p = 42;
To make sure the arguments are passed by reference in a method:

void foo(int &bar) { bar = 42; } // call it with the variable itself int i = 0; foo(i); printf("%i", i); // outputs 42

1
2
3
4
5
6
7
8

void foo(int &bar) {
bar = 42;
}

// call it with the variable itself
int i = 0;
foo(i);
printf("%i", i); // outputs 42
On the other hand, the same method using pointers must be passed the variables by reference in the call:

void foo(int *bar) { *bar = 42; } // call it with the references to the variable foo(&i);

1
2
3
4
5
6

void foo(int *bar) {
*bar = 42;
}

// call it with the references to the variable
foo(&i);

Managed instances

Instances of managed objects should be used through handles ( ^ , also called “hat”). It can be read “is a handle to the instance of the managed class”. Then, you use the handle as if it was the actual instance.

Note that, even though you don’t have to use managed objects in C++/CLI, you have to declare instances of managed objects with a handle.

public ref class Foo {
  int result; // native member
  System::String^ name; // managed member
};

// while the convention for pointers is to prefix "*" to the pointer name,
// the convention for handles is to suffix "^" to the class name
Foo^ f = gcnew Foo();
printf("%s", f.name);

public ref class Foo {

int result; // native member

System::String^ name; // managed member

};

// while the convention for pointers is to prefix "*" to the pointer name,

// the convention for handles is to suffix "^" to the class name

Foo^ f = gcnew Foo();

printf("%s", f.name);

Managed pointers

Because of garbage collection (which changes memory addresses), you can’t just use a regular C/C++ pointer to a managed objects. The managed pointers are called interior pointers. A good overview can be found here.

The syntax for interior pointers is very… declarative:

interior_ptr<int> p = &f->result;

1	interior_ptr<int> p = &f->result;

Native pointers are automatically converted to interior pointers (the inverse is not true):

void foo(interior_ptr<int> i) {
  *i = 42;
}

foo(&f->result); // passing a native pointer to the method

void foo(interior_ptr<int> i) {

*i = 42;

}

foo(&f->result); // passing a native pointer to the method

As with pointers in C++, usage interior pointers is not recommended, and you should rather use managed references.

Managed references

A managed reference is called a tracking reference and uses % instead of & .

void foo(int %i) {
  i = 42;
}

foo(f->result);

void foo(int %i) {

i = 42;

}

foo(f->result);

Managed pointers and references have some weirdness, for which this SO post goes into further details.

C++/CLI wrapping a C library: cheatsheet

Because once in a while I write a C++/CLI wrapper around a C library, but since I do it so infrequently I forget everything each time. Here is a list of pointers (haha) for common pitfalls and problems.

Compiling and debugging

You have to wrap the .h into an #ifdef __cplusplus extern “C” :

#ifdef __cplusplus
extern "C" {
#endif

// contents of the .h file

#ifdef __cplusplus
}
#endif

#ifdef __cplusplus

extern "C" {

#endif

// contents of the .h file

#ifdef __cplusplus

}

#endif

You also need to remove the /clr option for C files.
Right click your C files > Properties > C/C++ > General > Common Language RunTime Support > No CLR Support.

In your managed class, to include an unmanaged C header, use managed(push|pop)

#pragma managed(push, off)
#include "../../map_packer/packer.h"
#pragma managed(pop)

#pragma managed(push, off)

#include "../../map_packer/packer.h"

#pragma managed(pop)

Because Linux and Windows get along so well, you may also have to redefine a few C methods in your header file.

// Only for Visual C++
#ifdef _MSC_VER

// The Visual C++ compiler doesn't know "inline" but knows "__inline".
// see: stackoverflow.com/a/24435157/2354542
#define inline __inline

// Visual C++ is not POSIX compliant :'( so I have to code a new random() method
// rand() is not safe for security ; see: https://www.securecoding.cert.org/confluence/display/seccode/MSC30-C.+Do+not+use+the+rand%28%29+function+for+generating+pseudorandom+numbers
// but there is no security concern in my library, so I don't care much
inline long int random() {
    return rand();
}
#endif

// Only for Visual C++

#ifdef _MSC_VER

// The Visual C++ compiler doesn't know "inline" but knows "__inline".

// see: stackoverflow.com/a/24435157/2354542

#define inline __inline

// Visual C++ is not POSIX compliant :'( so I have to code a new random() method

// rand() is not safe for security ; see: https://www.securecoding.cert.org/confluence/display/seccode/MSC30-C.+Do+not+use+the+rand%28%29+function+for+generating+pseudorandom+numbers

// but there is no security concern in my library, so I don't care much

inline long int random() {

return rand();

}

#endif

If you wish to create a C# unit test project (using xUnit for instance), with Visual Studio 2012 and later, you will have to do a few things:

In the C++/CLI project’s properties, in Debugging, choose the Debugger Type “Mixed”
In the Visual Studio options, Debugging, check “Managed C++ Compatibility Mode” (in VS2012) / “Use Managed Compatibility Mode” (in VS2013).

To build using MSBuild, you may have to change the toolset to VS2012: project properties > General > Platform Toolset = Visual Studio 2012 (v110). And set the Configuration Type to Dynamic Library (.dll) while you’re at it.

Managed and unmanaged objects

gcnew instantiates a managed objects, which will be garbage collected. Always use it for the managed objects.

To easily call the native structures through managed classes, use the internal constructor and ToNative methods.

Creating a C++/CLI wrapper around a C library

So, following my previous post, I have decided that I might try C++/CLI after all, since the SWIG way goes nowhere except “down in flames”, and I really need to implement it.

Turns out that creating a C++/CLI wrapper around a fairly well-made C library is not that hard.

Considering the following .h file from the C library (which are the methods and structures to interface):

typedef struct {
	int left;
	int top;
	int right;
	int bottom;
} frame_t;

typedef struct {
	/* IN */
	int width;
	int height;

	/* OUT */
	frame_t view;
	frame_t dest;
} image_t;

typedef struct {
	int page_width;
	int page_height;
	int margin;
	int nb_run;
} parameters_t;

int pack(image_t *images, int nb_images, parameters_t params);

typedef struct {

int left;

int top;

int right;

int bottom;

} frame_t;

typedef struct {

/* IN */

int width;

int height;

/* OUT */

frame_t view;

frame_t dest;

} image_t;

typedef struct {

int page_width;

int page_height;

int margin;

int nb_run;

} parameters_t;

int pack(image_t *images, int nb_images, parameters_t params);

Add the .h and .c files to a new C++ CLR DLL project, then add a new cpp file, in which we will replicate all the C structures as classes.
We have to name our classes differently than the C structures, otherwise there will be conflicts, both with the compiler, and in our heads.

#include <windows.h>
#include <vcclr.h>
#include "../../packer/packer.h"
#using <System.dll>
#using <mscorlib.dll>

using namespace System;

namespace Packer {

    public ref class Frame {
    public:
        int Left, Top, Right, Bottom;

    internal:
        frame_t ToNative() {
            frame_t f;
            f.left = Left;
            f.top = Top;
            f.right = Right;
            f.bottom = Bottom;
            return f;
        }

        Frame() { }

        Frame(const frame_t &f) {
            Left = f.left;
            Top = f.top;
            Right = f.right;
            Bottom = f.bottom;
        }
    };

    public ref class Image {
    public:
        int Width, Height;
        Frame ^View, ^Dest;
        
        Image() {
            View = gcnew Frame();
            Dest = gcnew Frame();
        }

    internal:
        image_t ToNative() {
            image_t i;
            i.width = Width;
            i.height = Height;
            i.view = View->ToNative();
            i.dest = Dest->ToNative();
            return i;
        }
    };

    public ref class Parameters {
    public:
        int PageWidth, PageHeight, Margin, NbRun;

    internal:
        parameters_t ToNative() {
            parameters_t p;
            p.page_width = PageWidth;
            p.page_height = PageHeight;
            p.margin = Margin;
            p.nb_run = NbRun;
            return p;
        }
    };

    public ref class Packer {
    private:
        int _nb_images;
        image_t* nativeImages;
    public:
        Packer(int nb_images) {
            _nb_images = nb_images;
            nativeImages = new image_t[_nb_images];
        }
        ~Packer() {
            delete[] nativeImages;
        }
        int Pack(array< Image^ >^% images, Parameters^ params) {
            // create a native array of image_t to send to the C library
            for(int i = 0; i < _nb_images; i++) {
                nativeImages[i] = images[i]->ToNative();
            }
            
            // call the packing method
            int result = pack(nativeImages, _nb_images, params->ToNative());

            // re-loop on images to get the values from native images, and assign them to managed images
            for(int i = 0; i < _nb_images; i++) {
                images[i]->View = gcnew Frame(nativeImages[i].view);
                images[i]->Dest = gcnew Frame(nativeImages[i].dest);
            }

            return result;
        }
    };
}

100

101

#include <windows.h>

#include <vcclr.h>

#include "../../packer/packer.h"

#using <System.dll>

#using <mscorlib.dll>

using namespace System;

namespace Packer {

public ref class Frame {

public:

int Left, Top, Right, Bottom;

internal:

frame_t ToNative() {

frame_t f;

f.left = Left;

f.top = Top;

f.right = Right;

f.bottom = Bottom;

return f;

}

Frame() { }

Frame(const frame_t &f) {

Left = f.left;

Top = f.top;

Right = f.right;

Bottom = f.bottom;

}

};

public ref class Image {

public:

int Width, Height;

Frame ^View, ^Dest;

Image() {

View = gcnew Frame();

Dest = gcnew Frame();

}

internal:

image_t ToNative() {

image_t i;

i.width = Width;

i.height = Height;

i.view = View->ToNative();

i.dest = Dest->ToNative();

return i;

}

};

public ref class Parameters {

public:

int PageWidth, PageHeight, Margin, NbRun;

internal:

parameters_t ToNative() {

parameters_t p;

p.page_width = PageWidth;

p.page_height = PageHeight;

p.margin = Margin;

p.nb_run = NbRun;

return p;

}

};

public ref class Packer {

private:

int _nb_images;

image_t* nativeImages;

public:

Packer(int nb_images) {

_nb_images = nb_images;

nativeImages = new image_t[_nb_images];

}

~Packer() {

delete[] nativeImages;

}

int Pack(array< Image^ >^% images, Parameters^ params) {

// create a native array of image_t to send to the C library

for(int i = 0; i < _nb_images; i++) {

nativeImages[i] = images[i]->ToNative();

}

// call the packing method

int result = pack(nativeImages, _nb_images, params->ToNative());

// re-loop on images to get the values from native images, and assign them to managed images

for(int i = 0; i < _nb_images; i++) {

images[i]->View = gcnew Frame(nativeImages[i].view);

images[i]->Dest = gcnew Frame(nativeImages[i].dest);

}

return result;

}

};

}

The annoying thing when like me, you know pretty much nothing about C/C++, is that you never know where to specify pointers and stuff, and it’s mostly trial and error (it says it can’t build, let’s add a *… nope, a & ? Yes, that seems to work).

A few things to note:

Provide internal ToNative() methods on the structure wrappers to ease up marshalling from managed objects to native structures.
Also provide internal constructors taking a native structure as parameter, to ease up marshalling from native to managed.
The “^%” syntax (for the “images” parameter of the “Pack” method) builds to a “ref” in the .Net method signature. Otherwise the calling C# can’t get the values back.

As you can see, it’s not that difficult after all. I guess for an experienced C/C++ developer it would be even more simple.

Tag: cli

C, C++ and C++/CLI cheat sheet

How to read pointers

In variable declaration

In variable usage

C pointers

C arrays

C structures

C++ references

Managed instances

Managed pointers

Managed references

Further readings

C++/CLI wrapping a C library: cheatsheet

Compiling and debugging

Managed and unmanaged objects

Creating a C++/CLI wrapper around a C library