☆

C++ Basic: bits, simply data type

Jin Tu

Bolg: http://www.inblogs.net/havdone

Abstraction

This article help to make sense the various data types in programming languages by C++ data type.

32 bits Operation System

X-bits (32 bits or 64bits) operation system refers primarily to the number of bits used to represent memory addresses is x bits in operation system. (www.webopedia.com)

In 32 bits windows, the length of all pointers is 32 bits. “Operating systems based on Microsoft Windows NT technologies have always provided applications with a flat 32-bit virtual address space that describes 4 gigabytes (GB) of virtual memory. The address space is usually split so that 2 GB of address space is directly accessible to the application and the other 2 GB is only accessible to the Windows executive software.”(Microsoft)

C++ simply data type

The simply data type is the fundamental data type in c++ as it has become the building block of a structured data type. (Malik, D, S 2004) It can be categorized into three types:

1. Intergral: to deal with integers, or numbers without a decimal part;

2. Floating-point: to deals with decimal numbers;

3. Enumeration type: it is a user-defined data type. (Malik, D, S 2004)

Integral data type in C++ contains:

l short(2 bytes)

l long(4 bytes)

l int(4 bytes)

l bool(1 byte)

l char(1 bytes)

l unsigned char

l unsigned short

l unsigned int

l unsigned long

The smallest data type is char (1 byte), and the largest data type is long. And 1 byte equals 8 bits.

Floating-point data type contains:

l float(4 bytes)

l double(8 bytes)

l long double (8 bytes)

² Long double and double actually is the same for the newer compiler;

² A wchar_t data type actually is an unsigned short type, as they are all unsigned double bytes;

² A bool type also is a int type, and its value is zero or one;

² A int type is a long type

The differences between long and float

float i=111111;//111111.00

long l=111111;//111111

float data type:80 03 d9 47

long data type:07 b2 01 00

As mentioned in the above section, long is a data type which deals with integer and numbers without decimal part, and float is a data type which deals with decimal number(-3.4E+38 to 3.4E+38).

Type Conversion

Implicit or explicit conversion

It is likely that successfully implicit or explicit converting smaller bytes of data type to larger bytes of data type, otherwise, it is likely that uncertain danger occur. The positively safe conversions include:

l int to float and float to double

l char to wchar_t

l char to int

l short to long

l bool to int

l wchar_t to unsigned short

l long to int and short to int

l

It should be verified by programmers whether it is safe for conversions except the above. For instance:

l int to char or int to long or int to short

l wchar_t to char

l short to wchar_t

Conversion functions

Example

//////////////////////////////////////////////////////////

//Pretend 1 byte = 8 bits

//////////////////////////////////////////////////////////

int i=9;// 4 bytes=32bits

short s=1;//2 bytes

long l=2L;//4 bytes

char c='3';//1byte

float f=111111;//4 bytes

long l1=111111;

double d=333333;//8 bytes

long double ld=333333;// 8 bytes

wchar_t w='4';//2 bytes

wchar_t wc=L'五';//2 bytes, L get the Unicode of right nearest string or char,

//make targets to 2 bytes unsigned data type

unsigned uVal = 328u; // Unsigned value

long lVal = 0x7FFFFFL; // Long value specified

//as hex constant

unsigned long ulVal = 0776745ul; // Unsigned long value

////////////////////////////////////////////////////////////////////////

//Convertion

//from smaller bytes of data type to larger bytes of data type, it is safe!

//from a data type to the same bytes of data type, it is safe!

//////////////////////////////////////////////////////////////////////

//char to int: 1 byte to 4 byte

char cc='h';

int ic=int(cc);//equal static_cast cc

//put pointer's value (address) into long data type.

//pointer is 32-bit(4 bytes) data type in 32 bit OS

//4 bytes to 4 bytes

char * pc="test";

long sc =long(pc);

long * lp=(long*)sc;

//char to wchar_t:1 byte to 2 byte

wchar_t wcc=wchar_t(cc);

//wchar_t to short: 2 bytes to 2 bytes

short sct=short(wcc);

//wchar_t * to short *:ponter of 2bytes to pointer of 2bytes

wchar_t* wcp=L"fsd";

long lwcp=long(wcp);

unsigned short * uswcp=(unsigned short*)lwcp;

unsigned short * sp=(unsigned short *) wcp;

☆

C# p/invoke: marshaling class between C# and C++ class

Jin Tu

Blog: http://www.inblogs.net/havdone

1.0 Abstraction

This article provides basic information to realize how pass c# function pointer and class object to a c++ function as parameters.

2.0 Mechanism

The c++ function parameters could be an object pointer or a function pointer. Passing c# class object or a function as parameter to c++ function actually is passing a C# reference or a function pointer. To realize this mechanism properly, first should make sense of the basic knowledge in its scope.

3.0 Basic knowledge

3.1 C# pointer (*)

The c# unsafe code can use pointer directive (*). However, c# pointer has many constraints. As stated in MSDN, “C# pointer types do not inherit from object and no conversions exist between pointer types and object. Also, boxing and unboxing do not support pointers. However, you can convert between different pointer types and between pointer types and integral types.”

“Any of the following types may be a pointer type:

• sbyte, byte, short, ushort, int, uint, long, ulong, char, float, double, decimal, or bool.
• Any enum type.
• Any pointer type.
• Any user-defined struct type that contains fields of unmanaged types only.”

That means c# cannot make conversion from class object reference to pointer type (*). Using “&” operator on a reference, will cause a compiling error “Cannot take the address of, get the size of, or declare a pointer to a managed type”.

3.2 Reference parameters in C#

While reference object, such as a class object, is pass to function as a parameter, actually the address of object is passed, as reference is a pointer type.

3.3 Class data type in memory

[System.Runtime.InteropServices.StructLayout(LayoutKind.Sequential)]

class Class1

{

public int i;

private int _i;

public System.Collections.ArrayList arr = new System.Collections.ArrayList();

public void test()

{

Console.WriteLine("hello world!");

}

public Class1()

{

_i = 400;

}

};

The above graph shows how a Class1 object is allocated memory.

3.4 Delegate in C#

“The delegate keyword is used to declare a reference type that can be used to encapsulate a named or an anonymous method.”(MSDN)

4.0 Marshaling Example

This example passes class object that mentioned in chapter 3.3, to a c++ dll. C++ code use a class type object to accept the fields values of c# object and use a function pointer parameter to accept c# object function.

/////////////////////////////////////////////////////////

//C# Code

///////////////////////////////////////////////////////////

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Runtime.InteropServices;

namespace interoperation

{

class Program

{

//////////////////////////////////////////////////////////

//P/Invoke a c++ function declare

///////////////////////////////////////////////////////////

//if do not explcit point out entrypoint

//the c# function name must be the same with c++ code

[System.Runtime.InteropServices.DllImport("..\\..\\..\\debug\\sort.dll")]

public static extern void func(Class1 arrays, Program.delgFunc func);

//////////////////////////////////////////////////////////

//C# function pointer declare

///////////////////////////////////////////////////////////

public delegate void delgFunc();

static void Main(string[] args)

{

Class1 obj = new Class1();

Program.delgFunc delg = obj.test;

//pass a class reference and a function pointer to c++ function

func(obj, delg);

}

};

[System.Runtime.InteropServices.StructLayout(LayoutKind.Sequential)]

class Class1

{

public void test()

{

Console.WriteLine("c# function is called");

Console.WriteLine("_i="+this._i.ToString());

}

public System.Collections.ArrayList arr = new System.Collections.ArrayList();

private int _i;

public int i;

public Class1()

{

_i = 400;

i = 333;

}

};

}

/////////////////////////////////////////////////////////

//C++ Code

///////////////////////////////////////////////////////////

// Sort.cpp : Defines the exported functions for the DLL application.

//

#include "stdafx.h"

#include

using namespace std;

extern "C"

{

//////////////////////////////////////////////////////////////////////

//To accept C# class object,

//remember c++ fileds are allocated memory sequentially

///////////////////////////////////////////////////////////////////////

class Class1

{

public :

void * unknow;//accept arr of c# object

int _i;//accept _i of c# object

int i; //accept i of c# object

};

__declspec(dllexport) void func(Class1* class1,void (* test)())

{

cout<<"(C# object is passed !) The value of private field '_i': "<_i<<"\n";

cout<<"(C# object is passed !) The value of public field 'i': "<i<<"\n";

test();

}

}

The output like this: