The gcroot template is implemented using the facilities of the value class System::Runtime::InteropServices::GCHandle, which provides "handles" into the garbage-collected heap. Note that the handles themselves are not garbage collected and are freed when no longer in use by the destructor in the gcroot class (this destructor cannot be called manually). If you instantiate a gcroot object on the native heap, you must call delete on that resource.

The runtime will maintain an association between the handle and the CLR object, which it references. When the CLR object moves with the garbage-collected heap, the handle will return the new address of the object. A variable does not have to be pinned before it is assigned to a gcroot template.

Example

This sample shows how to create a gcroot object on the native stack.

// mcpp_gcroot.cpp

// compile with: /clr

#include <vcclr.h>

using namespace System;

class CppClass {

public:

   gcroot<String^> str;   // can use str as if it were String^

   CppClass() {}

};

int main() {

   CppClass c;

   c.str = gcnew String("hello");

   Console::WriteLine( c.str );   // no cast required

}

Output

hello

This sample shows how to create a gcroot object on the native heap.

// mcpp_gcroot_2.cpp

// compile with: /clr

// compile with: /clr

#include <vcclr.h>

using namespace System;

struct CppClass {

   gcroot<String ^> * str;

   CppClass() : str(new gcroot<String ^>) {}

   ~CppClass() { delete str; }

};

int main() {

   CppClass c;

   *c.str = gcnew String("hello");

   Console::WriteLine( *c.str );

}

Output

hello

This sample shows how to gcroot to hold references to value types (not reference types) in a native type by using gcroot on the boxed type.

// mcpp_gcroot_3.cpp

// compile with: /clr

#include < vcclr.h >

using namespace System;

public value struct V {

   String^ str;

};

class Native {

public:

   gcroot< V^ > v_handle;

};

int main() {

   Native native;

   V v;

   native.v_handle = v;

   native.v_handle->str = "Hello";

   Console::WriteLine("String in V: {0}", native.v_handle->str);

}

Output

String in V: hello

Read original article here.

Share on Facebook

In some programs, you may need to represent a list of items that share some characteristics. You can declare as many variables as necessary to represent such items. Here is an example of 5 numbers declared in a program:

// This is the main project file for VC++ application project
// generated using an Application Wizard.

#include "stdafx.h"

#using <mscorlib.dll>

using namespace System;

int _tmain()
{
    // TODO: Please replace the sample code below with your own.
    int number1 = 266;
    int number1 = -4683;
    int number1 = -364;
    int number1 = 1450;
    int number1 = 8;

    Console::WriteLine();
    return 0;
}

If you want to use a group of objects that are of the same kind, C++ allows you to identify them as one variable. An array is a group of variables that shared the same characteristics.

Note:

Arrays in Managed C++ are a little different than those traditionally used in C++ because the Microsoft .NET Framework introduced a new way of declaring and using arrays, which also has to do with inherited classes. Because this can be a long and arduous subject, we will use arrays only as they are used and implemented in managed classes.

Array Declaration

An array is a group of values of the same kind or the same data type. Because the items are considered in a group, they are declared as one variable but the declaration must indicate that the variable represents various items. The items that are part of the group are also referred to as members of the array. To declare an array, you must give it a name.

In C++, the formula to declare an array is

DataType ArrayName[Dimension];

With this formula, an array would be declared as a value type. C++’ arrays can be declared either on the stack as in the above formula or on the heap. Managed C++ formally introduces the idea of declaring an array on the heap. Based on this, (most) arrays in Managed C++ are referred to as managed arrays. In this case, the formula to declare a managed array is:

DataType ArrayName[] = new DataType[Dimension];

Another equivalent formula is:

DataType ArrayName __gc[] = new DataType __gc[Dimension];

Therefore, the declaration of a managed array starts by specifying a data type, the DataType in our syntax. This indicates the kind of values shared by the members of the array. It also specify the amount of memory space that each member of the array will need to store its value. Like any other variable, an array must have a name, which is the ArrayName in our syntax. The name of the array must be followed by an opening and a closing square brackets "[]". To indicate that you are declaring a managed array, you must assign the same data type as a managed type, using the new keyword. Once again, the data type must be followed by square brackets. This time, inside of the square brackets, you must type the number of items that the array is made of; that is the Dimension in our syntax.

To create a managed array, the data type can be a normal C/C++ data type such as int, double, or .NET value type such as Int32, Double, etc. Here is an example:

// This is the main project file for VC++ application project
// generated using an Application Wizard.

#include "stdafx.h"

#using <mscorlib.dll>

using namespace System;

int _tmain()
{
    // TODO: Please replace the sample code below with your own.
    Double Number[] = new Double[5];

    Console::WriteLine(S"");
    return 0;
}

To re-enforce the idea of declaring a managed array, you can optionally type the __gc keyword to the left of the square brackets. You can type it either on only one side of the assignment operator or on both sides. Therefore, the following declarations are equivalents:

// This is the main project file for VC++ application project
// generated using an Application Wizard.

#include "stdafx.h"

#using <mscorlib.dll>

using namespace System;

int _tmain()
{
    // TODO: Please replace the sample code below with your own.
    Double Number1[]      = new Double[5];
    Double Number2 __gc[] = new Double[5];
    Double Number3[]      = new Double __gc[5];
    Double Number4 __gc[] = new Double __gc[5];

    Console::WriteLine();
    return 0;
}

When declaring a managed array, you must use the new operator to indicate to the compiler that the variable would be declared on the heap. Because the new operator is explicit enough, you can omit the __gc keyword. Also, you don’t have to perform the whole declaration at the same time but you must have requested that memory be allocated to the array before it can be used. Based on this, you can first declare the variable with the left part of the assignment operator. Then, when you are ready, you can allocate memory to the variable and specify the number of members of the array. When doing this, type the name of the variable without the square brackets and type the right side of our syntax. Here is an example:

// This is the main project file for VC++ application project
// generated using an Application Wizard.

#include "stdafx.h"

#using <mscorlib.dll>

using namespace System;

int _tmain()
{
    // TODO: Please replace the sample code below with your own.
    Double number[];
    // You can't yet use the array

    Console::WriteLine(S"The Wonderful World of Managed C++!");

    number = __gc new Double[5];
    // Now the array is ready

    Console::WriteLine();
    return 0;
}

We mentioned that, when declaring the array, you should specify the number of members of the array with the Dimension in our syntax. After declaring the array, if you want, you can reduce or increase the number of items by simply performing a new assignment to the variable and indicating the new desired Dimension. Here is an example:

// This is the main project file for VC++ application project
// generated using an Application Wizard.

#include "stdafx.h"

#using <mscorlib.dll>

using namespace System;

int _tmain()
{
    // TODO: Please replace the sample code below with your own.
    Double number[];
    // You can't yet use the array

    Console::WriteLine(S"The Wonderful World of Managed C++!");

    number = __gc new Double[5];
    // Now the array is ready

    // The new dimension of the array
    number = new Double[8];

    Console::WriteLine();
    return 0;
}

Initializing an Array

When declaring an array, before using it, we saw that you must specify the number of members of the array. This declaration allocates an amount of memory space to the variable. The first member of the array takes a portion of this space. The second member of the array occupies memory next to it:

Array Variable

Member1

Member2

Member3

Member4

Member5

Each member of the array can be accessed using its position. The position is also referred to as an index. The members of an array are arranged starting at index 0, followed by index 1, then index 2, etc. This system of counting is referred to as "zero-based" because the counting starts at 0. To locate a member, type the name of the variable followed by an opening and a closing square brackets. Inside the bracket, type the zero-based index of the desired member. After locating the desired member of the array, you can assign it a value, exactly as you would any regular variable. Here is an example:

// This is the main project file for VC++ application project
// generated using an Application Wizard.

#include "stdafx.h"

#using <mscorlib.dll>

using namespace System;

int _tmain()
{
    // TODO: Please replace the sample code below with your own.
    Double number[] = __gc new Double[5];

    number[0] = 643.18;
    number[1] = 9.64;
    number[2] = 48.05;
    number[3] = 14.26;
    number[4] = 62.55;

    Console::WriteLine(S"");
    return 0;
}

In the same way, you can retrieve the value of a member of an array based on its index. Such a value can be displayed to the user as follows:

// This is the main project file for VC++ application project
// generated using an Application Wizard.

#include "stdafx.h"

#using <mscorlib.dll>

using namespace System;

int _tmain()
{
    // TODO: Please replace the sample code below with your own.
    Double number[] = __gc new Double[5];

    number[0] = 643.18;
    number[1] = 9.64;
    number[2] = 48.05;
    number[3] = 14.26;
    number[4] = 62.55;

    Console::WriteLine(S"Value 1: {0}", __box(number[0]));
    Console::WriteLine(S"Value 2: {0}", __box(number[1]));
    Console::WriteLine(S"Value 3: {0}", __box(number[2]));
    Console::WriteLine(S"Value 4: {0}", __box(number[3]));
    Console::WriteLine(S"Value 5: {0}", __box(number[4]));

    number = new Double[8];

    Console::WriteLine(S"");
    return 0;
}

This would produce:

Value 1: 643.18
Value 2: 9.64
Value 3: 48.05
Value 4: 14.26
Value 5: 62.55

Press any key to continue

When it comes to initializing a managed array, you don’t have to access each member of the array and initialize them individually. That technique is used if you don’t yet have the values of the items at the time you are declaring the array. If you know the values of the members of the managed array at the time you are declaring its variable, you can declare and initialize the whole array at the same time. The formula you would use is:

DataType VariableName __gc[] = { Values Separated By Commas };

This formula is almost the same used in C/C++ with one difference. If you omit the __gc keyword, the array would be a regular one as used in C/C++. The alternative is to type the __gc keyword to the left of the square brackets. If you do this, two features would automatically be applied to your array. First, the array would be garbage collected, that is, cleaned up by the garbage collector; therefore becoming a managed array. Second, the array becomes automatically derived from the .NET’s Array class, which gives it access to the properties and methods of that class.

If you use the formula we used earlier with the number variable, the data type must be a .NET value type such as Int32, Double, Single, etc. If you use the above formula to declare and initialize your array, the data type can be a regular C/C++ type (such as int, long, or double) or a .NET value type (such as Int32 or Double). Here is an example:

// This is the main project file for VC++ application project
// generated using an Application Wizard.

#include "stdafx.h"

#using <mscorlib.dll>

using namespace System;

int _tmain()
{
    // TODO: Please replace the sample code below with your own.
    double number __gc[] = { 79.31, 47.59, 749.75, 9.07, 9.44 };

    Console::WriteLine(S"Value 1:  {0}", __box(number[0]));
    Console::WriteLine(S"Value 2:  {0}", __box(number[1]));
    Console::WriteLine(S"Value 3:  {0}", __box(number[2]));
    Console::WriteLine(S"Value 4:  {0}", __box(number[3]));
    Console::WriteLine(S"Value 5:  {0}", __box(number[4]));

    Console::WriteLine(S"");
    return 0;
}

This would produce:

Value 1:  79.31
Value 2:  47.59
Value 3:  749.75
Value 4:  9.07
Value 5:  9.44

Press any key to continue

Multidimensional Arrays

Introduction

The arrays we have used so far are referred to as single or one-dimensional arrays because they use a single group of items that can classified in a single column. In some cases, you may want to divided the list in two or more sections. For example, here is a list of numbers divided in various columns:

Sunday

Monday

Tuesday

Wednesday

Thursday

Friday

Saturday

Week 1

1

2

3

4

5

6

7

Week 2

8

9

10

11

12

13

14

Week 3

15

16

17

18

19

20

21

Week 4

22

23

24

25

26

27

28

A multi-dimensional array is one that still includes items of the same type but the group is made of sub-divisions following an arrangement an arrangement of your choice.

Two-Dimensional Arrays

Imagine you create two lists of items declared in two variables as follows:

// This is the main project file for VC++ application project
// generated using an Application Wizard.

#include "stdafx.h"

#using <mscorlib.dll>

using namespace System;

int _tmain()
{
    // TODO: Please replace the sample code below with your own.
    Double number1 __gc[] = new Double __gc[5];
    Double number2 __gc[] = new Double __gc[5];

    number1[0] = 643.18;
    number1[1] = 9.64;
    number1[2] = -48.05;
    number1[3] = 14.26;
    number1[4] = 62.55;

    number2[0] = 124.45;
    number2[1] = -62.84;
    number2[2] = 508.06;
    number2[3] = 92.68;
    number2[4] = -44.82;

    Console::WriteLine(S"Value 1:  {0}", __box(number1[0]));
    Console::WriteLine(S"Value 2:  {0}", __box(number1[1]));
    Console::WriteLine(S"Value 3:  {0}", __box(number1[2]));
    Console::WriteLine(S"Value 4:  {0}", __box(number1[3]));
    Console::WriteLine(S"Value 5:  {0}", __box(number1[4]));

    Console::WriteLine(S"Value 6:  {0}", __box(number2[0]));
    Console::WriteLine(S"Value 7:  {0}", __box(number2[1]));
    Console::WriteLine(S"Value 8:  {0}", __box(number2[2]));
    Console::WriteLine(S"Value 9:  {0}", __box(number2[3]));
    Console::WriteLine(S"Value 10: {0}", __box(number2[4]));

    Console::WriteLine(S"");
    return 0;
}

Instead of having two lists that represent the same types of values, you can declare a single array variable and divide its list of items in two. A two-dimensional array is an array made of two lists of items of the same data type. To declare a two-dimensional array, use the following formula:

DataType ArrayName[,] = new DataType[Dimension1,Dimension2];

Once again, you can optionally type the __gc keyword to the left of square brackets. The square brackets to the left of the assignment operator must have only a comma. Inside of the square brackets to the right side of the assignment, you must specify two numbers separated by a comma. The first number indicates the number of lists that the array contains. For a two-dimensional array, this number must be 2. The right value indicates the number of items that each list would contain. Here is an example:

// This is the main project file for VC++ application project
// generated using an Application Wizard.

#include "stdafx.h"

#using <mscorlib.dll>

using namespace System;

int _tmain()
{
    // TODO: Please replace the sample code below with your own.
    Double number __gc[,] = new Double __gc[2,5];

    Console::WriteLine(S"");
    return 0;
}

In this case, the number variable is a two-dimensional array. In other words, the variable represents two lists. Each list contains 5 numbers.

To access a member of the array, type the name of the variable followed by the square brackets. Inside of the brackets, type the zero-based index of the desired list. The first list has an index of 0 while the second list has an index of 1. Then type the comma. On the right side of the comma, type the zero-based index of the member you want to access. Once you have accessed a member of the array, you can either assign it a value or retrieve the value it is currently holding. Here are examples:

// This is the main project file for VC++ application project
// generated using an Application Wizard.

#include "stdafx.h"

#using <mscorlib.dll>

using namespace System;

int _tmain()
{
    // TODO: Please replace the sample code below with your own.
    Double number __gc[,] = new Double __gc[2,5];

    number[0,0] = 643.18;
    number[0,1] = 9.64;
    number[0,2] = -48.05;
    number[0,3] = 14.26;
    number[0,4] = 62.55;

    number[1,0] = 124.45;
    number[1,1] = -62.84;
    number[1,2] = 508.06;
    number[1,3] = 92.68;
    number[1,4] = -44.82;

    Console::WriteLine(S"Value 1:  {0}", __box(number[0,0]));
    Console::WriteLine(S"Value 2:  {0}", __box(number[0,1]));
    Console::WriteLine(S"Value 3:  {0}", __box(number[0,2]));
    Console::WriteLine(S"Value 4:  {0}", __box(number[0,3]));
    Console::WriteLine(S"Value 5:  {0}", __box(number[0,4]));

    Console::WriteLine(S"Value 6:  {0}", __box(number[1,0]));
    Console::WriteLine(S"Value 7:  {0}", __box(number[1,1]));
    Console::WriteLine(S"Value 8:  {0}", __box(number[1,2]));
    Console::WriteLine(S"Value 9:  {0}", __box(number[1,3]));
    Console::WriteLine(S"Value 10: {0}", __box(number[1,4]));

    Console::WriteLine(S"");
    return 0;
}

This would produce:

Value 1:  643.18
Value 2:  9.64
Value 3:  -48.05
Value 4:  14.26
Value 5:  62.55
Value 6:  124.45
Value 7:  -62.84
Value 8:  508.06
Value 9:  92.68
Value 10: -44.82

Press any key to continue

Multi-Dimensional Arrays

A multi-dimensional array is a list of a list of a list, etc. In other words, it is a list that contains other lists while these other lists may contain other lists. For example, a three-dimensional array is one that contains 3 lists; each of the 3 lists contains a certain number of lists; then each list inside contains a list of items.

To declare a multi-dimensional array, in the square brackets, type the number of comma minus the total number of lists. For example, the square brackets of a three-dimensional array would have 2 commas. The square brackets of a 5-dimensional array would have 4 commas. In the square brackets on the right side of the assignment operator must indicate the dimension of each level of list. Consider the following declaration:

// This is the main project file for VC++ application project
// generated using an Application Wizard.

#include "stdafx.h"

#using <mscorlib.dll>

using namespace System;

int _tmain()
{
    // TODO: Please replace the sample code below with your own.
    Double hoursWorked __gc[,,] = new Double[6,3,5];

    Console::WriteLine();
    return 0;
}

In this declaration, the variable represents 6 lists. Each of the 6 lists is made of its own 3 lists. Each of the 3 lists contains 5 items. Another ways to illustrate this is that the array represents 6 months work for a contractor. In each of the six months, the contractor worked for 3 weeks. In each of the 3 weeks, the contractor worked for 5 days.

You can access each member of a multi-dimensional array using its index. In the above example, the first month has an index of 0 while the third month has an index of 2. Everything else is as done for the other dimensional arrays.

The String as an Array and Characters

An Array of Characters

In C/C++, you can declare a string variable as an array of characters. Here is an example:

// This is the main project file for VC++ application project
// generated using an Application Wizard.

#include "stdafx.h"

#using <mscorlib.dll>

using namespace System;

int _tmain()
{
    // TODO: Please replace the sample code below with your own.
    char School[] = "American College of Computer & Information Sciences";

    Console::Write("School Name: ");
    Console::WriteLine(School);

    Console::WriteLine(S"");
    return 0;
}

This would produce:

School Name: American College of Computer & Information Sciences

Press any key to continue

In various previous examples, we used the .NET’s String class to declare and process string variables. In some cases, you will need access to one character inside of a string. In C/C++, if you declare a string using an array of characters as done above, to access an individual character, you type the name of the variable followed by square brackets. Inside of the square brackets, you can type the 0-based index of the character you want to access. Remember that the C/C++ char data type is an 8-bit value (to access a character, you should use its Char or __wchar_t type). Here is an example:

// This is the main project file for VC++ application project
// generated using an Application Wizard.

#include "stdafx.h"

#using <mscorlib.dll>

using namespace System;

int _tmain()
{
    // TODO: Please replace the sample code below with your own.
    char School[] = "American College of Computer & Information Sciences";
    Char First    = School[0];
    Char Second   = School[9];
    Char Third    = School[20];
    Char Fourth   = School[31];
    Char Fifth    = School[43];

    Console::Write("School Name: ");
    Console::WriteLine(School);
    Console::WriteLine(S"Abbreviation: {0}{1}{2}{3}{4}",
	              __box(First), __box(Second), __box(Third),
	              __box(Fourth), __box(Fifth));

    Console::WriteLine(S"");
    return 0;
}

This would produce:

School Name: American College of Computer & Information Sciences
Abbreviation: ACCIS

Press any key to continue

The Characters of a String Class Value

Many libraries that feature a string class, such as the ATL’s basic_string class, the MFC’s CString class, or the VCL’s AnsiString class provide you the same mechanism (by overloading the [] operator). The Microsoft .NET Framework’s String class provides a different functionality. If you declare a String variable and want to access any of its characters, the String class provides a Chars property that uses square brackets to locate a character. This is done using the same approach as above except that you must call the Chars property. Here is an example of how this can be done:

// This is the main project file for VC++ application project
// generated using an Application Wizard.

#include "stdafx.h"

#using <mscorlib.dll>

using namespace System;

int _tmain()
{
    // TODO: Please replace the sample code below with your own.
    String* School = "American College of Computer & Information Sciences";
    Char First    = School->Chars[0];
    Char Second   = School->Chars[9];
    Char Third    = School->Chars[20];
    Char Fourth   = School->Chars[31];
    Char Fifth    = School->Chars[43];

    Console::Write("School Name: ");
    Console::WriteLine(School);
    Console::WriteLine(S"Abbreviation: {0}{1}{2}{3}{4}",
	              __box(First), __box(Second), __box(Third),
	              __box(Fourth), __box(Fifth));

    Console::WriteLine(S"");
    return 0;
}

It would produce the same result.

Arrays and Functions

An Array as Argument

An array can be passed to a function as argument. An array can also be returned by a function. To specify that a function takes an array as argument, declare the function as you would do for any regular function. In the parentheses of the function, declare the array with the __gc keyword as you have done so far. Here is an example:

// This is the main project file for VC++ application project
// generated using an Application Wizard.

#include "stdafx.h"

#using <mscorlib.dll>

using namespace System;

void ShowNumbers(double n __gc[]);

int _tmain()
{
    // TODO: Please replace the sample code below with your own.

    Console::WriteLine(S"");
    return 0;
}

When implementing the function, proceed as you would do normally. If you want to access the members of the array, use the same technique we have used so far, accessing each member of the array by its index. When you call the function from another function, simply pass the name of the array as argument. This would be done as follows:

// This is the main project file for VC++ application project
// generated using an Application Wizard.

#include "stdafx.h"

#using <mscorlib.dll>

using namespace System;

void ShowNumbers(double n __gc[]);

int _tmain()
{
    // TODO: Please replace the sample code below with your own.
    Double number[]= { 643.18, 9.64, 48.05, 14.26, 62.55 };

    ShowNumbers(number);

    Console::WriteLine(S"");
    return 0;
}

void ShowNumbers(double Nbr __gc[])
{
    Console::WriteLine(S"Value 1: {0}", __box(Nbr[0]));
    Console::WriteLine(S"Value 2: {0}", __box(Nbr[1]));
    Console::WriteLine(S"Value 3: {0}", __box(Nbr[2]));
    Console::WriteLine(S"Value 4: {0}", __box(Nbr[3]));
    Console::WriteLine(S"Value 5: {0}", __box(Nbr[4]));
}

This would produce:

Value 1: 643.18
Value 2: 9.64
Value 3: 48.05
Value 4: 14.26
Value 5: 62.55

Press any key to continue

If you create a function that takes a non-managed array as argument, you usually would pass an additional argument that carries the size of the array. On the other hand, if you create a function that takes a managed array as argument, since the array would inherit from the Array class, the argument would automatically carry its dimension from the Length property of the Array class. Therefore, with a managed array as argument, you don’t have to specify the number of members to the function; the compiler would figure that out.

Returning an Array

Whether in C/C++ or Managed C++, an array is (always) passed as a reference. Although in C/C++, there is no formal way to return an array from a function, because an array is passed as a reference, it is very easy to return an array. Actually, this technique is used in C++ as an accessory, not as a means. Managed C++ formal features the idea of returning an array from a function. Although this is a new feature not available in C/C++, it is very easy to use, so easy that there is very little effort to implement this valuable addition.

To indicate that a function would return an array, if you are only declaring the function, type empty square brackets between the function’s parentheses and its semi-colon. Here is an example:

// This is the main project file for VC++ application project
// generated using an Application Wizard.

#include "stdafx.h"

#using <mscorlib.dll>

using namespace System;

Double GetNumbers()[];

void ShowNumbers(double n __gc[]);

int _tmain()
{
    // TODO: Please replace the sample code below with your own.

    Console::WriteLine(S"");
    return 0;
}

When defining the function, type the square brackets between the function’s parentheses and its opening curly bracket. In the body of the function, you can declare an array, do what you want with it, and then return it as the return value of the function.

When calling a function that returns an array, proceed with the rules you would use for any other function. For example, you can call the function in another and use it as you see fit. You can also assign the function to an array variable in order to initialize the variable. Here is an example:

// This is the main project file for VC++ application project
// generated using an Application Wizard.

#include "stdafx.h"

#using <mscorlib.dll>

using namespace System;

Double GetNumbers()[];

void ShowNumbers(double n __gc[]);

int _tmain()
{
    // TODO: Please replace the sample code below with your own.
    Double no __gc[] = GetNumbers();
    ShowNumbers(no);

    Console::WriteLine(S"");
    return 0;
}

Double GetNumbers()[]
{
    Double number[] = { 643.18, 9.64, 48.05, 14.26, 62.55 };

    return number;
}

void ShowNumbers(double Nbr __gc[])
{
    Console::WriteLine(S"Value 1: {0}", __box(Nbr[0]));
    Console::WriteLine(S"Value 2: {0}", __box(Nbr[1]));
    Console::WriteLine(S"Value 3: {0}", __box(Nbr[2]));
    Console::WriteLine(S"Value 4: {0}", __box(Nbr[3]));
    Console::WriteLine(S"Value 5: {0}", __box(Nbr[4]));
}

Share on Facebook

So I came up with a simple three step process to download all the images on a given page easily.

1. Save the html source of the Flickr.com page.

2. Give the source to this C++ code and get download links to all images.

3. Download all the images using FlashGet.

PS: If someone could write a Java script of this C++ code and write a wrapper to automatically get the HTML source, the above can be reduced to just one step.

Share on Facebook

   1: #include <iostream.h>

   2: using namespace std;

   3:  

   4: int main()

   5: {

   6:     const int x = 10;

   7:     int * ptr;

   8:     ptr = (int *)( &x );    //make the pointer to constant int*

   9:     

  10:     *ptr = 8;               //change the value of the constant using the pointer.

  11:  

  12:     //here is the real surprising part

  13:     cout<<"x: "<<x<<endl;          //prints 10, means value is not changed

  14:     cout<<"*ptr: "<<*ptr<<endl;    //prints 8, means value is changed

  15:     cout<<"ptr: "<<(int)ptr<<endl; //prints some address lets say 0xfadc02

  16:     cout<<"&x: "<<(int)&x<<endl;   //prints the same address, i.e. 0xfadc02

  17:     //This means that x resides at the same location ptr points to yet 

  18:     //two different values are printed, I cant understand this.

  19:     

  20:     return 0;

  21: }

If anyone knows the reason, please post it here.

Share on Facebook

Wouldn’t it be nice if all this information were kept in one location? The obvious place to put this information is in the source code itself; this makes it easy to modify the docs along with the code. But it is hard enough to go through someone else’s program when you know how to code, let alone when you are less technically savvy. Also, adding code documentation takes time.
This article will show you how to solve many of those problems using XML comments. Code comments, user manuals, developer manuals, test plans, and many other documents can be generated from a single source using XML tags. I’ll explain how to insert XML comments and enable exportation of these comments to another file. I’ll then discuss each of the available tags and the format of the XML file where the tags are used and walk through an example of using XML comments and XSLT to generate help files.

XML Comments

All XML comments begin with three forward slashes (///). The first two slashes signify a comment and tell the compiler to ignore the text that follows. The third slash tells the parser that this is an XML comment and should be handled appropriately.
      When the developer types the three forward slashes, the Microsoft® Visual Studio® .NET IDE checks to see if it precedes an identifiable type or type member definition. If it is identifiable, then the Visual Studio .NET IDE will automatically insert a few comment tags. The developer then adds additional tags and values as needed. For example, here are the XML tags that are generated when the three forward slashes are entered before this member function that has a parameter:

/// <summary>
///
/// </summary>
/// <param name="strFilePath"></param>
public void LoadXMLFromFile(string strFilePath)

The tags inserted here represent only a couple of many that the Visual Studio .NET IDE already knows.

While the current implementation of IntelliSense® for XML comments does not show all the tags listed in the C# specification, the missing tags can always be inserted manually.

      Once comments are inserted, it would be useful to do something with them. If you set things up correctly (as I’ll explain shortly), this usually just means exporting all the text that comes after the three forward slashes into an external file.

      There are also several predefined XML comment tags that the parser knows. When these tags are encountered (and have been used correctly by the developer), the parser will format the tags’ output to a text file. If a tag that is not predefined is encountered, it is just written verbatim along with any text to the external file. This means that you can make up your own tags or you can even use known tags recognizable from another source (such as HTML) in the comments.

      When exportation is set up correctly, the C# parser extracts the XML comments, does formatting if needed, and places them into an XML file of your choice. You can set the location and file name of the XML document file, and enable exportation, through your project’s property pages. To do this, follow these four steps:

• Open the property page for the project, usually by right-clicking on the project in the Solution Explorer, and click Properties.
• After the dialog has opened, click the Configuration Properties folder.
• Click the Build option.
• In the right pane, there will be a property field called XML Documentation File. Set this to the path and file name of the desired file. The path entered is relative to the project directory, not absolute.

Recognized Tags

I have classified the XML comment tags into two categories. The first set of tags, which I’ll call primary tags, always starts a group of XML comment tags. They are never embedded within other tags. The second set contains tags that are used within primary tags as modifiers to the text. I call them support tags.

here are nine primary tags: <remarks>, <summary>, <example>, <exception>, <param>, <permission>, <returns>, <seealso>, and <include>.

      In this context, the <remarks> tag is used to describe a type such as a class:

/// <remarks>
/// Class that contains functions to do
/// transformations to help files.
/// </remarks>

The C# documentation recommends using <remarks> to describe a type and a <summary> tag to describe a type member.Oddly, if you start a comment before a type using the /// combination, the Visual Studio .NET IDE will still insert a <summary> tag. Therefore, <remarks> tags need to be inserted manually.

The <summary> tag is the tag found most often in a C# source file. This tag is used to describe type members, including methods, properties, and fields:

/// <summary>
/// This XmlDocument based attribute contains the
/// XML documentation for the project.
/// </summary>

The <summary> tag can describe types as well, but it is not recommended. The XML comment documentation recommends that the <remarks> tag be used for describing types.

The <example> tag is used to mark the beginning of an example showing how to use the item. The example can be any valid text, but most often it is a snippet of code:

/// <example>
/// <code>
/// // create the class that does translations
/// GiveHelpTransforms ght = new GiveHelpTransforms();
/// // have it load our XML into the SourceXML property
/// ght.LoadXMLFromFile(
///  "E:\\Inetpub\\wwwroot\\GiveHelp\\GiveHelpDoc.xml");
/// </code>
/// </example>

If code is used, it is usually marked with a <code> tag. The <code> tag will be discussed in the section on support tags.

The <exception> tag documents the exceptions, if any, that the item may throw. If more than one exception may be thrown, then more than one of these tags may be used. Unlike most of the tags, the <exception> tag has one attribute, cref. The value of this attribute is the name of the exception that could be thrown. This must be a valid class because the C# parser will verify it and extract the context information to put into the XML documentation. I will explain this later.

I did not throw any exceptions in the code for this article, but here is an example of how the cref attribute can be used with the <exception> tag:

/// <exception cref="SampleException">
/// Normally, a discussion on any exceptions thrown would go here.
/// </exception>

The <param> tag describes the parameters of a method or property. It is automatically inserted by the IDE when using the three forward slashes before a method. The <param> tag has one attribute, name, which is simply the same name that the parameter has in the source:

/// <param name="strFilePath">The path to the file containing the
/// source XML.</param>

Member access is identified with the <permission> tag. The text that is assigned to it sets permission-related descriptions. There is no requirement for the value for this tag. Permission is one possibility, with values such as public, private, protected, and so on. Scope is another possible value, with information about whether the method is static. However, you are free to put whatever value you must have here.

The <permission> tag has one attribute—cref. The documentation describes the use of cref in this context as "a reference to a member or field that is available to be called from the current compilation environment." It is usually set to System.Security.PermissionSet:

/// <permission cref="System.Security.PermissionSet">Public
/// Access</permission>

The <returns> tag is similar to the <param> tag, but it’s used to describe what the method or property returns:

/// <returns>The HTML for a list of types based on the XML
/// documentation.</returns>

The <seealso> tag specifies "other" links related to the same topic. This tag usually does not include a text value, just a cref attribute that specifies a reference to a symbol. This could be a type, member, field, and so on.

/// <seealso cref="GiveMemberListHTMLHelp"/>

The XML compiler will identify the content of the symbol and use it accordingly in the compiled XML documentation. I’ll discuss this again in the section on the XML documentation file.

When XML comments are extracted from the code by the compiler, any file specified in the <include> tag will be expanded and the comments inside it will be used as if that had been included inline. Because the compiler finds them, you can keep comments in an external file. This can help organize your code, but then the comments are not readily available. I would never use the <include> tag for this reason, but if your comments are lengthy, you may find the trade-off acceptable.

      Several attributes must accompany the <include> tag to specify the external file. The file attribute is the name of the file using relative or fully qualified paths. The include file itself is an XML document that holds XML comments. The path attribute is an XPath statement that points to the parent element of the XML comments in the external document, as you can see here:

/// <include file='MyXMLCommentFile.xml'
/// path='doc/members/member[@name="T:MyExampleClass"]/*'/>
public class MyExampleClass
{
/// <include file='MyXMLCommentFile.xml'
   /// path='doc/members/member[@name="M:MyExampleMethod"]/*'/>
   public string MyExampleMethod(string strReturnThis)
   {
     return strReturnThis;
   }
}

Support Tags

      There are eleven support tags: <c>, <code>, <list>, <listheader>, <item>, <term>, <description>, <para>, <paramref>, <see>, and <value>.

      The <c> tag marks a line of text as code. It is usually used inline in descriptive text.

/// The source XML is loaded into the <see cref="SourceXML"/>
/// property (e.g. <c><I>obj</I>.SourceXML =
/// "<I>XML goes here</I>"</c>).

The <code> tag also defines a section of text as code. It is often used within an <example> tag block (as shown earlier). The <code> tag is similar to the <c> tag, but <c> is used for a single line of code while <code> is used for a block of code. It specifies that the formatting of the text in the comments needs to remain the same:

/// <code>
/// // create the class that does translations
/// GiveHelpTransforms ght = new GiveHelpTransforms();
/// // have it load our XML into the SourceXML property
/// ght.LoadXMLFromFile(
///      "E:\\Inetpub\\wwwroot\\GiveHelp\\GiveHelpDoc.xml");
/// </code>

The <list> tag is used in other comment tags to define a specialized list. The type of list is defined by the type attribute, which can have the values bullet, number, or table. Within the <list> tag, there are tags that denote the components of the list, as you can see in this example:

/// <list type="table">
/// <listheader>
/// <term>Help Page</term>
/// <description>Function to call</description>
/// </listheader>
/// <item><term>List of Types</term>
/// <description>GiveTypeListHTMLHelp</description></item>
/// <item><term>List of members</term>
/// <description>GiveMemberListHTMLHelp</description></item>
/// <item><term>Help for a single member</term>
/// <description>GiveMemberHTMLHelp</description></item>
/// </list>

The <listheader> tag holds header information for the list (see the previous example). It is typically used for a table of list types.

As you probably guessed, the <item> tag identifies each item in the list. It can stand alone or wrap <term> and <description> tags. The <term> and <description> tags are always children tags of the <listheader> tag or <item> tags. They are always used in pairs and their function is obvious.

The <para> tag is used to identify a new paragraph. It is very similar to the <P> tag in HTML. You should definitely use this tag to break up long comment sections:

/// <summary>This is a summary.
/// <para>This is a new paragraph.</para>
/// </summary>

If text within a comment needs to have a parameter specially identified, then <paramref> is the tag to use. It is inserted in the text in the location where the parameter text should appear. The main purpose of this tag is to identify the name of a parameter that should be formatted in a special way. It has one attribute, name, which is the name of the parameter that would appear in the text, usually formatted in a special way:

/// Loads the XML documentation in the file specified by
/// <paramref>strFilePath</paramref>.

The <see> tag is used within the text of other comment tags to specify a hyperlink. It is used inline as part of the text and usually just includes one attribute, cref:

/// One of the associated member functions (<see
/// cref="GiveTypeListHTMLHelp"/>,
/// <see cref="GiveMemberListHTMLHelp"/>, <see
/// cref="GiveMemberHTMLHelp"/>)
/// is called to initiate and then return the transformation.

The cref attribute specifies a reference to an existing symbol. See the description for the <exception> tag for more information.

The <value> tag defines the meaning of a property member. It is used just like the <remarks> tag is used for classes and the <summary> tag is used for other members.

/// <value>
/// The SourceXML property contains the XML that will be used in
/// the transformations by the member functions for this class.
/// </value>

Generating Documentation

Now that you have successfully created an XML file from the comments you need to generate documentation from it. For this purpose you can download and use nDoc.

Once you have downloaded nDoc, you can use its GUI interface to select a binary from your project directory (make sure it is in the debug folder and the .XML is located next to it).

nDoc allows you to create different types of documentations from simple HTML to MSDN style.

If you need anymore help, please feel free to ask.

Related Article;

http://msdn.microsoft.com/en-us/magazine/cc302121.aspx

Share on Facebook

Input: This is a string

Output: string a is This

Solution: First of all we consider the simple string reverse function.

   1: void ReverseString(char str[])

   2: {

   3:     int size = strlen(str);

   4:     for ( int i = 0, j = size - 1; i < j; i++, j-- )

   5:     {

   6:         swap( str[i] , str[j] );

   7:     }

   8: }

This function would reverse the entire string irrespective of words.

Input: This is a string

Output: gnirts a si sihT

Our required output however is different. We need ‘string a is This’.

No compare the two;

Output1: gnirts a si sihT

Output2: string a is This

It is evident that we can get Ouput2 from output 1 just by reversing the individual words (Reversing something twice gives the original). Now that we know what to do, lets see how we can go about doing it.

First of all, it would be helpful to slightly modify the above function to work with start and end indexes of the string given.

   1: void ReverseString(char str[], int start, int end)

   2: {

   3:     for ( int i = start, j = end - 1; i < j; i++, j-- )

   4:     {

   5:         swap( str[i] , str[j] );

   6:     }

   7: }

Now to reverse an entire string you will call this function with start = 0 and end = strlen(str). But how does this help our  cause? Simple, we will first reverse the entire string and then pass the start and end index of each word to it making the words normal again.

Here is the code:

   1: void ReverseWordOrder(char str[])

   2: {

   3:     int size = strlen(str);

   4:     //Reverse the entire string

   5:     ReverseString(str, 0, size);

   6:     //Now we have: gnirts a si sihT

   7:     

   8:     //Now we will find start and end indexes of words

   9:     //and pass them to this function

  10:  

  11:     int i = 0;

  12:     int start, end;

  13:     while(i < size)

  14:     {

  15:         //find the first char of the word

  16:         while(str[i] == ' ')

  17:             i++;

  18:         start = i;

  19:         //look for the end of a word

  20:         while(str[i] != ' ' && str[i] != '\0')

  21:             i++;

  22:         end = i;

  23:         ReverseString(str, start, end);

  24:     }   

  25: }

This solution is has a running time of O(n) ( T(n) = 3n to be precise ). The first ReverseString takes n steps, the while loop itself is again has proportional to n steps. Internal call to ReverseString takes n steps in all (Can you tell how?).

Can it be further reduced without using extra memory? Post answers with proof please (for a bonus of course).

Share on Facebook

So I though of using the ‘this’ pointer. Obviously the ‘this’ pointer is not static and cannot be used in a static context. As a work around i introduced a static member inside the dialog box class that was a pointer to the dialog box class itself. Since this pointer was static it could be used from the static context of the function. Now to keep this pointer pointing to whatever ‘this’ is pointing to, one can either use the gain focus event of the dialog box or some other event as may be appropriate to make the static pointer equal to ‘this’ pointer. Once this is done the static function can use the static pointer to make changes inside the GUI, while the thread can call this function just like a normal function (non member).

Here is the signature i used to pass the function to the thread.

   1:  

   2: void (*printFunction)(char * message);

This allows any function that accepts a char string and returns void to be used with the thread, allowing it to be used in many a context.

This article was written in very short time, if you find something lacking, please feel free to ask.

Share on Facebook

Callback function

A callback function is a function whose pointer is passed to another function and and that function calls the first function using the pointer. When such a call is made, it is said that a callback has been made.

Why use a Callback?

You must be wondering why use a callback? Consider the scenario where you are implementing a sorting technique based on comparisons. You want it to be generic and allow the user to choose which number goes first (ascending sort or descending sort). To solve this you can have the user pass a function to your sort program and you can use that function to decide which number goes first. Here you are only making a callback and you do not care how or where the function is implemented, neither does the writer of the passed function care who or where the caller is.

How its done?

First i create a class for sorting numbers that requires a callback function and makes a callback.

   1: class SortNumber

   2: {

   3: public: 

   4:     SortNumber(int * a, int s)

   5:     {

   6:         arr = a;

   7:         size = s;

   8:     }

   9:  

  10:     void Sort( bool (*sortOrder(int , int)) )

  11:     {

  12:         // sort algorithm that uses the sortOrder

  13:         // as (*sortOrder)(firstNum, secondNum);

  14:     }    

  15: };

In the above code we have a class that sort an array of integers. In all comparison sorts, we need to be able to make decision whether two number are out of place or not. However, this decision can be made in a variety of ways (Can you figure out why a variety of ways and not just two?). The user can then supply a function of their own choosing how different numbers are treated in comparison.

The comments inside the sort function also show how to make the call back. This whole exercise when a function pointer is passed to another function and the pointer is used to call that function is called a callback.

Share on Facebook

They are really nice when you don’t know how many of a data type you will need, and don’t want to waste space. They are like having a dynamically allocated string that fluctuates in size as the program runs. Before I really confuse you lets get into a better explanation!

A linked list is a chain of structs or records called nodes. Each node has at least two members, one of which points to the next item or node in the list! These are defined as Single Linked Lists because they only point to the next item, and not the previous. Those that do point to both are called Doubly Linked Lists or Circular Linked Lists. Please note that there is a distinct difference betweeen Double Linked lists and Circular Linked lists. I won’t go into any depth on it because it doesn’t concern this tutorial. According to this definition, we could have our record hold anything we wanted! The only drawback is that each record must be an instance of the same structure. This means that we couldn’t have a record with a char pointing to another structure holding a short, a char array, and a long. Again, they have to be instances of the same structure for this to work. Another cool aspect is that each structure can be located anywhere in memory, each node doesn’t have to be linear in memory!

   1: class List

   2: {

   3:     long Data;

   4:     List* Next;

   5:     List(long d)

   6:     {

   7:         Data = d;

   8:         Next = NULL;

   9:     }

  10: };

Notice that we define a constructor for our class that sets Next equal to NULL. This is because we need to know when we have reached the end of our linked list. Each Next item that is NOT equal to NULL means that it is pointing to another allocated instance. If it does equal NULL, then we have reached the end of our list.

Starting up

First off, we need to set our Link pointers to some know location in memory. We will create a temp pointer, allocate an instance, then assign our pointers. Something like this:

   1: SLList:: SLList()

   2: {

   3:     Head = NULL;

   4:     Tail=Head;

   5:     CurrentPtr = Head;

   6: }

We have allocated no memory for out link list nodes. So no nodes exist at the time, some call this the smallest possible like list, others require at least one node. I support the first point of view.

Adding a Node

We can actually add nodes in two possible places, the beginning or the end, although the standard seems to be the end. This makes our linked list act kind of like a queue with the head node being the oldest and end pointing to the newest objects. This brings up an interesting subject also. How will we use our linked list? This is what makes the linked list so powerful. We could use it as a priority list where the oldest objects get a higher precedence until deleted from the list. We could also use it as a master listing of items that need to be kept track of at one time, deleting object when they need to be, without using any precedence scheme. Here’s some code that will add a node onto the end of the list, and then move the end pointer so that it really does point at the end.

Following is the code to add a node at the start of the link list. If the tail is NULL then we have no nodes and the new node is the tail node.

   1: void AddAtStart(int d)

   2: {

   3:     Node * newNode = new Node(d);

   4:     if (tal == NULL)

   5:     {

   6:         tail = newNode;

   7:     }

   8: }

Here we try and add a node at the end of the link list. If there are no nodes in the link list, it is the same as adding a node at the start of the link list so we use that function.

   1: void AddAtEnd(int d)

   2: {

   3:     if (tail == NULL)

   4:     {

   5:         AddAtStart(d);

   6:     }

   7:     else

   8:     {

   9:         Node * newNode = new Node(d);

  10:         tail->next = newNode;

  11:         tail = newNode;

  12:     }

  13: }

We make another function, add after. This function adds a node after the given node.

   1: void AddAfter(Node * p, int d)

   2: {

   3:     Node * newNode = new Node(d);

   4:     newNode->next = p->next;

   5:     p->next = newNode;

   6:     if (p == tail)

   7:         tail = newNode;    

   8: }

We will use this function in our sorted addition function. To implement a sorted insertion function, we need to know the node after which the node is to be added. We have four cases:

1. The link list is empty
2. The given data is less than the head data (to be inserted at the start)
3. The given data is greater than the tail node (to be inserted at the end of the node)
4. When the data is to be inserted somewhere in the middle

   1: void AddSorted(int d)

   2: {

   3:     if (head == NULL)

   4:     {

   5:         AddAtStart(d);

   6:     }

   7:     else if (d < head->data)

   8:     {

   9:         AddAtStart(d);

  10:     }

  11:     else if (d > tail->data)

  12:     {

  13:         AddAtEnd(d);

  14:     }

  15:     else

  16:     {

  17:         for (Node * temp = head; temp->next != NULL; temp = temp->next)

  18:         {

  19:             if (temp->next->data > d)

  20:             {

  21:                 AddAfter(temp, d);

  22:                 break;

  23:             }

  24:         }

  25:     }

  26: }

Share on Facebook