bool getCUGParameter(const G_String& number, int *cugIndex,
int *createTS, int *terminateTS)
{
    int mycharstr[100];
    int mycharstr1[30];
    int mycharstr2[30];
    int mycharstr3[30];
    G_DynArray<Parameter> matchedstrlist;
    G_String matchedstr;
    G_String lookupvalue;
    int numofmatchedstr;
 
    memset(mycharstr, '\0', sizeof(mycharstr));
    memset(mycharstr1, '\0', sizeof(mycharstr1));
    memset(mycharstr2, '\0', sizeof(mycharstr2));
    memset(mycharstr3, '\0', sizeof(mycharstr3));
 
    // find all matches number from mCUGParameter
    matchedstrlist = mCUGParameter.findMultipleMatchesWithoutEIgnoreSpace(number);
    numofmatchedstr = matchedstrlist.size();
 
    if (numofmatchedstr > 0) {
        int m;
        for (m=0; m <= numofmatchedstr; m++) {
              lookupvalue=matchedstrlist[m].getValue();
              removeBlank(lookupvalue);
              sscanf(lookupvalue.cStr(), "%s", mycharstr);
 
              int i = 0;
              int j = 0;
              int k = 0;
 
              for (i=0; mycharstr[i] != '\0'; i++) {
                   if (mycharstr[i] == ',') {
                         j++;
                         k = 0;
                   } else {
                         if (j == 0) {
                              mycharstr1[k] = mycharstr[i];
                          } else if (j == 1) {
                              mycharstr2[k] = mycharstr[i];
                          } else if (j ==2) {
                              mycharstr3[k] = mycharstr[i];
                          } else {
                              // do nothing
                          }
                          k++;
                   }
                   cugIndex[m] = mycharstr1[k];
                   createTS[m] = mycharstr2[k];
                   terminateTS[m] = mycharstr3[k];
              }
        }
 
        for (m=0; m < numofmatchedstr; m++) {
             cout << "TEST: " << cugIndex[m] << " - " << createTS[m] << " - " << terminateTS[m] << endl;
        }
        return true;
    } else {
        return false;
    }
}

#include <iostream>
#include <vector>
#include <algorithm>

template<const int N>
int array_size(const int (&arr)[N] )
{ 
    return N;
}

int main()
{
    typedef std::vector<int>::iterator iter_t;

//Just for the purpose of this example, populating
// an STL vector container using an array initialiser.
    const int lookup_table[] = { 2,3,5,5,11,13,11 } ;
    std::vector<int> my_vec(lookup_table, 
                            lookup_table + array_size(lookup_table) );

//Sorting all elements in the container:
// Make sure that all elements in the container are in order
// so that std::unique can identify all duplicates.
    std::sort(my_vec.begin(), my_vec.end());

    iter_t new_end;
    new_end = std::unique(my_vec.begin(),
                          my_vec.end() );

//Now the container is too big and has some unwanted data at the end
// lets get rid of those unwanted elements.
    my_vec.erase(new_end, my_vec.end());

    for( iter_t it = my_vec.begin(); it != my_vec.end(); ++it)
        std::cout << *it << std::endl;
}