Managed C++/CLI

#include <stdio.h>
#include<string.h>

char f[10000];
char factorial[1010][10000];

void multiply(int k)
{
int cin,sum,i;
int len = strlen(f);
cin=0;
i=0;
while(i<len)
{
sum=cin+(f[i] - '0') * k;
f[i] = (sum % 10) + '0';
i++;
cin = sum/10;
}
while(cin>0)
{
f[i++] = (cin%10) + '0';
cin/=10;
}
f[i]='\0';
for(int j=0;j<i;j++)
factorial[k][j]=f[j];

factorial[k][i]='\0';
}
void fac()
{
int k;
strcpy(f,"1");
for(k=2;k<=1000;k++)
multiply(k);
}
void print(int n)
{
int i;
int len = strlen(factorial[n]);
printf("%d!\n",n);
for(i=len-1;i>=0;i--)
printf("%c",factorial[n][i]);
printf("\n");
}
int main()
{
int n;
factorial[0][0]='1';
factorial[1][0]='1';
fac();
while(scanf("%d",&n)==1){
print(1);
}
return 0;
}

#ifndef __GLIST_H
#define __GLIST_H

#include <assert.h>
#include <STDIO.H>
#include <STDLIB.H>
#include <STRING.H>
#include <STRNG.H>
#include <MALLOC.H>

typedef enum bool { false, true};

/* -------------------- Define class GList ----------------- */
class GList
{
   private:
     char    **arr;
     int     length;
     void    FillEmptyAll(int);
     void    ResizeList(int);
     void    SetArr(char **);
     void    SetLen(size_t);
     char    **GetArr() { return arr; }

   public:
     size_t  GetLen();
     void    Add(const char*);
     void    Add(String);
     void    SetValue(size_t, const char*);
     void    SetValue(size_t, String);
     char*   GetValue(size_t);
     void    InsertValue(size_t, const char*);
     void    InsertValue(size_t, String);
     void    FillEmptyRange(size_t, size_t);
     void    CreateMemList(size_t);
    // void    ResizeMemList(int);
     void    RemoveAt(size_t);
     void    RemoveRange(size_t, size_t);
     void    RemoveValue(const char *);
     void    RemoveValue(String);
     void    RemoveAllValue(const char *);
     void    RemoveAllValue(String);

	     GList();
	     GList(const GList& L); //Copy constructor
	     //GList(const GList* &L);
	     GList&  operator=(const GList& L); //assignment operator =
	     //GList&  operator=(const GList* &L);
     virtual ~GList();
};

/* Constructor */
inline GList::GList(void)
{
   length = 1;
   arr    = (char**) malloc(sizeof(char*) * length);
   //arr    = NULL;
}

/* Define Copy Constructor */
inline GList::GList(const GList& L): length(L.length),
				     arr((char**)malloc(sizeof(char*) * L.length))
{
   int idx = L.length - 1;
   for(int i = 0; i < idx; i++){
      *(arr + i) = *(L.arr + i);
   }
   *(arr + idx) = 0;
}

/* Define operator = */
inline GList& GList::operator=(const GList& L)
{
   if (this == &L) return *this;
   else
   {
      length = L.length;
      if (arr != 0)
      {
	 free(arr);
	 arr = 0;
      }
      arr     = (char**)malloc(sizeof(char*) * L.length);
      int idx =  L.length - 1;
      for(int i = 0; i < idx; i++)
	 *(arr + i) = *(L.arr + i);

      *(arr + idx) = 0;
   }
   return *this;
}

/* Destructor */
inline GList::~GList()
{
   if (arr != 0)
   {
      free(arr);
      //arr = NULL;
   }
    printf("Destructor GList");
}

/* -------------- Define Property for GList ------------*/

/* Fill All Value in arr = "" ----------- */
void GList::FillEmptyAll(int len)
{
   for(int i = 0; i < len; i++)
      *(arr + i) = strdup("");
   *(arr + len) = 0;
}

/* -------- Fill Empty Value from startAt, to startEnd ----------- */
void GList::FillEmptyRange(size_t startAt, size_t startEnd)
{
   if (startEnd - startAt <= 0) return;
   //for(int i = startAt; i < startEnd-1; i++)
   for(int i = startAt; i < startEnd; i++)
       //*(arr + i) = strdup("");
      SetValue(i, "");
}

/* --------- Create List with numData Value and Fill it empty ----- */
/* example GList(3), create 4 blocks : 3 contains data, 1 pointer NULL */
void GList::CreateMemList(size_t numData)
{
   if (numData == 0 || numData == 1)
   {
      length = 1;
      if (arr != 0)
	 free(arr);
      arr    = (char**) malloc(sizeof(char*) * length);

   }
   else
   {
      //if (this->arr) free(this->arr);
      //length = numData + 1;
      length = numData;
      if (arr != 0)
      {
	 free(arr);
	 arr = 0;
      }
      arr = (char**) malloc(sizeof(char*) * length);
      if (arr == 0)
      {
	  printf("Create new memory for List failed! Not enough memory");
	  abort();
      }
      /* Fill empty value to array */
      FillEmptyAll(length - 1);
   }
}

/* ----------- Return length of GList ------------ */
size_t GList::GetLen(void)
{
   if (length == 0)
      return 0;

   return length-1;
}

/* ------------ Replace new value at Index ------------- */
void GList::SetValue(size_t index, const char *value)
{
  //if ((index < 0) || (index >= GetLen()))
  if (index >= GetLen())
     return;
  else
     *(arr + index) = strdup(value);
}

void GList::SetValue(size_t index, String value)
{
  char *string = strdup(value);
  SetValue(index, string);

  if (string != NULL)
     delete string;
}

/* ---------------- Set new length for pointer array ------------ */
/* Warning : new length may be effect by GetValue --------------- */
void GList::SetLen(size_t newlength)
{
  if (newlength <= 1)
    length = 1;

  length = newlength;
}

/* ---------- Set pointer array to GList ---------- */
/* Warning : new pointer array must same size old pointer array */
void GList::SetArr(char **array)
{
   arr = array;
}

/* ---------- Return value at Index ------------ */
char* GList::GetValue(size_t index)
{
   if (index >= GetLen() || index < 0)
      return NULL;
   else
      return *(arr + index);
}

/* ---------- Insert new value at index to GList ------------- */
void GList::InsertValue(size_t index, const char *value)
{
   char **newarr   = 0;
   int  i;
   int  newLen     = 0;
   int  idx        = 0;
   int  oldLen     = length - 1;

   if (index > oldLen || index < 0)
      return;

   length = length + 1; /* new real length assignment */
   idx    = length - 1;
   /* assign new array with new length */
   newarr = (char**) malloc(sizeof(char*) * length);
   if (newarr == 0)
   {
      printf("Insert new value to List failed! Not enought memory.");
      abort();
   }
   for(i = 0; i < index; i++)
       *(newarr + i) = *(arr + i);

   for(i = idx - 1; i > index; i--)
       *(newarr + i) = *(arr + (i-1));
   /* Insert new value to index */
   *(newarr + index) = strdup(value);
   /* assign NULL to last newarr */
   assert(idx = length - 1);
   *(newarr + idx) = 0;

   /* Free memory on old arr */
   if (arr != 0)
   {
      free(arr);
      arr  =  0;
   }
   arr     =  newarr;
   newarr  =  0;
   if (newarr == 0)
      delete newarr;
}

/* ---------- Insert new value at index to GList ------------- */
void GList::InsertValue(size_t index, String value)
{
   char *str = strdup(value);
   InsertValue(index, str);

   if (str != NULL)
      delete str;
}


/* -------- Add new value to GList at last position ---------*/
void GList::Add(const char *value)
{
   int idx  = length - 1;
   if (idx <= 0)
   {
      length = 2;
      if (arr != 0)
      {
	 free(arr);
	 arr = 0;
      }
      arr = (char**) malloc(sizeof(char*) * length);
      if (arr == 0)
      {
	 printf("Add new value to List failed!");
	 abort();
      }
      *(arr + 0) = strdup(value);
      *(arr + (length -1)) = 0;
   }
   else if (idx >= 1)
   {
      length++;
      char **newarr = 0;
      newarr = (char**) malloc(sizeof(char*) * length);
      if (newarr == 0)
      {
	printf("Add new value to List failed!\n");
	abort();
      }
      /* Copy data from old array to new array */
      for(int i = 0; i < idx; i++)
	 *(newarr + i) = *(arr + i);

      *(newarr + idx++) = strdup(value);
      assert(idx = length - 1);
      *(newarr + idx)   = 0;

   /* Free-up old array */
      if (arr != 0)
      {
	 free(arr);
	 arr = 0;
      }
      arr    = newarr;
      newarr = 0;

      if (newarr == 0)
	delete newarr;
   }
}

void GList::Add(String value)
{
   char *str = strdup(value);
   Add(str);

   if (str != NULL)
      delete str;
      //str = NULL;

}

/* ---------- Remove value at Index --------------- */
void GList::RemoveAt(size_t index)
{
   int i, idx;
   int len       = length - 1;


   idx = length - 1; /* Take old GetLen of old array arr */
   if (index >= len || idx == 0)
      return;

   /* Move data */
   for(i = index; i < idx - 1; i++)
   {
      *(arr + i) = *(arr + (i+1));
   }
   length = length - 1;
   char **newarr;
   /* Create new pointer array */
   newarr = (char**) malloc(sizeof(char*) * length);
   if (newarr == NULL)
   {
      printf("Remove at index %i in List failed!", index);
      abort();
   }
   /* Copy data from old arr to new arr */
   idx = idx - 1; /* Take new GetLen() for new array */
   for(i = 0; i < idx; i++)
      *(newarr + i) = *(arr + i);

   assert(idx = length - 1);
   *(newarr + idx) = 0;

   /*Free-up old array */
   if (arr != 0)
   {
      free(arr);
      arr = 0;
   }
   arr    = newarr;
   newarr = 0;
   if (newarr == 0)
      delete newarr;
}

/* ----------- Remove Range at startAt to startEnd from List ------- */
void GList::RemoveRange(size_t startAt, size_t startEnd)
{
   int  oldLen        = length - 1;
   int  numRemoveData = startEnd - startAt + 1;  /* Number of value Remove */
   int  numMoveData   = oldLen - numRemoveData - startAt; /* Number of value will be move */
   int  index         = 0;
   int  lock          = 0; /* key take NULL */

   if ((numRemoveData < 0) || startEnd > oldLen -1)
       return;

    /* Move oldLen - StartEnd value to Index startAt */
   for(index = 0; index < numMoveData; index++)
       *(arr + (index + startAt)) = *(arr + (startEnd + index + 1));

   if (startEnd == oldLen - 1)
       lock = startAt;
   else if (startEnd < oldLen - 1)
       lock = startAt + numMoveData;

   length = length - numRemoveData;
   if (length <= 1)
   {
       free(arr);
       arr    = 0;
       length = 1;
   }
   else if (length > 1)
   {
      char** newarr= 0;
      /* Create new array */
      newarr = (char**) malloc(sizeof(char*) * length);
      if (newarr == 0)
      {
	 printf("Remove range %i to %i  from List failed!",startAt, startEnd);
	 abort();
      }
      /* Copy value from old array to new array */
      for(index = 0; index < lock; index++)
	 *(newarr + index) = *(arr + index);

      assert(lock = length - 1);
      *(newarr + lock) = 0;

      /* Free-up old array */
      if (arr != 0)
      {
	 free(arr);
	 arr   =  0;
      }
      arr      =  newarr;
      newarr   =  0;
      if (newarr == 0)
	 delete newarr;
   }
}

/* ----------- Remove value in GList ------------- */
void GList::RemoveValue(const char *value)
{
   int pos    = 0;
   int index  = 0;
   bool found = false;
   int len    = length - 1;

   if ((value == NULL) || (len == 0)) return;
   while ((index < len) && !found)
   {
      pos = strcmp(arr[index],value);
      if (pos == 0)
	 found = true;
      else
	 index++;
   }
   if (found)
      RemoveAt(index);
}

void GList::RemoveValue(String value)
{
   char *str = strdup(value);
   RemoveValue(str);

   if (str != NULL)
      delete str;
}

/* ------------ Remove All Value contain string ----------- */
void GList::RemoveAllValue(const char *string)
{
   int  index      = 0;
   int  pos        = 0;

   if (string == NULL) return;
   while (index < GetLen())
   {
      pos = strcmp(*(arr + index), string);
      if (pos == 0)
	 RemoveAt(index);
      else
	 index++;
   }
}

void GList::RemoveAllValue(String string)
{
   char *str = strdup(string);
   RemoveAllValue(str);
   if (str != NULL)
      delete str;
}

/* ------------------ End of GList ------------------- */
#endif

#include <iniclass.h>
#include <hpclass.h>
#include <stdio.h>
#include <conio.h>

void main(int argc, char* argv[])
{
   //clrscr();
   int exit = 0;
   GList mList(Split(argv));
   INIClass ini(mList);
   exit = ini.Finaliaze();
   printf("\nEnd program - Exit code : %i",exit);
   //delete ini;
}