DSXchange

timsmith_s wrote:I found a few postings regarding this topic, but their C++ syntax was incorrect. The question really is, who owns the memory once I return the char* from the external function? All of the samples and the advanced course material always show constant values being return, but howdo I deal with variable length strings?

For example, the following code returns a buffer from the string, but NEW allocated the buffer, who DELETEs it (free's it), DSEE? I believe it will create a memory leak.

Should I be using the String Class provide in the APT framework API?

#include <string.h>

char* GenerateStringFromParameter (char* StringParameter)
{
char* buffer = 0;

// allocate strong long enough to hold the argument & some text
buffer = new char[strlen(StringParameter) + 12];

// copy the contents of the argument
strcpy(buffer, StringParameter);

// tack on some random text to make string longer than parameter
strcat(buffer, "hello world");

// return the newly created string
return buffer;
}

#include <string.h> 

char* GenerateStringFromParameter (char* StringParameter, char* buffer) 
{ 
// copy the contents of the argument 
strcpy(buffer, StringParameter); 

// tack on some random text to make string longer than parameter 
strcat(buffer, "hello world"); 

// return the newly created string 
return buffer; 
}

timsmith_s wrote: the issue, the my quesiton is, who cleans up the memory created by the NEW operator?

timsmith_s wrote:Interesting - so if I wanted to write my own trim function the signature would read

Trim(instring, outstring) rather than Trim(instring)

Why do the ~standard~ routines not require this sort of hassle? I was told they were handled in much the same way.

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

char* SybaseToOracleTp(char* InTp) 
{ 
  //Initialize variables 
  const int SIZE = 30; 
  char* month = (char *)malloc(SIZE); 
  char* day = (char *)malloc(SIZE); 
  char* year = (char *)malloc(SIZE); 
  char* hour = (char *)malloc(SIZE); 
  char* newHr = (char *)malloc(SIZE); 
  char* min = (char *)malloc(SIZE); 
  char* sec = (char *)malloc(SIZE); 
  char* msec = (char *)malloc(SIZE); 
  char* time = (char *)malloc(SIZE); 
  char* intMon = (char *)malloc(SIZE); 
  char* finOut = (char *)malloc(SIZE); 
  const char* calender[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"}; 

  int hr = 0; 

  //AM or PM 
  char* p = strstr(InTp, "PM"); 

  //Disect the Date 
  strcpy(month, strtok(InTp, " ")); 
  strcpy(day, strtok(NULL, " ")); 
  strcpy(year, strtok(NULL, " ")); 
  strcpy(time, strtok(NULL," ")); 

 //Disect Time 
  strcpy(hour, strtok(time, ":")); 
  strcpy(min, strtok(NULL, ":")); 
  strcpy(sec, strtok(NULL, ":")); 
  strcpy(msec, strtok(NULL, ":")); 

  //get numeric representation of Month 
  for(int i = 0; i < 12; i++) 
  { 
   if (strcmp(month, calender[i]) == 0) 
     sprintf(intMon, "%02d", i + 1); 
  } 
  if ((p) && strcmp(hour, "12") != 0) 
    { 
     hr = atoi(hour); 
     hr+=12; 
     sprintf(hour, "%02d", hr); 
    } 
  
  if ((!p) && strcmp(hour, "12") == 0) 
  { 
     strcpy(hour, "00"); 
  } 
 //format string to YYYY-MM-DD HH:MM:SS.sss 
 sprintf(finOut, "%s-%2s-%s %s:%s:%s.%s", year, intMon, day, hour, min, sec, msec); 

 //free memory 
 free(month); 
 free(day); 
 free(year); 
 free(hour); 
 free(min); 
 free(sec); 
 free(msec); 
 free(time); 
 free(intMon); 

 return finOut; 

} 

DSguru2B wrote:I would rather define LocalBuffer as a pointer but anyhow. You are right when you say that the scope of this variable is untill the call to the function finishes, but then again thats all that we want. A C function is what a px routine is. Its just a function. For every row the function will be invoked and once the function finishes, the memory is released. So if you have 100 rows in your source file and you are calling the function in the transformer, the function will be called 100 times.
The variable that holds the end result, i.e, is used in the return command, the memory for this variable will be released when the function completes. Any other variable you use inside, make sure you free it within the code. I like to do that.
Check out this amature code that I wrote.

Yuan_Edward wrote:DSguru2B, I pasted your codes here, will the memory buffer (finOut) be released by DataStage (I am quite sure it will not be released by the routine itself)? That's OP's question. DataStage needs to call "free" or "delete" explicitly to release the memory. I cant find any documentation on that.