String in ANSI C?

I have a few suggestions.

First you are not verifying that realloc() properly allocated memory. When using realloc() you should use two pointers so you can properly check for a successful allocation:

char * increaseBuffer(char * buff, size_t newBuffSize)
{
   void * ptr;

   // adjust buffer size
   ptr = realloc(buff, newBuffSize);

   // verify allocation was successful
   if (ptr == NULL)
   {
      perror("realloc()"); // prints error message to Stderr
      return(buff);
   };

   // adjust buff to refer to new memory allocation
   buff = ptr;

   /* use buffer for something */

   return(buff);
};

Since your InitStr() function is only providing an initial allocation, you can simplify it to:

char *InitStr(){
    char * ReturnStr;

    // allocate new buffer
    ReturnStr = malloc(1);

    // verify allocation was successful before using buffer
    if (ReturnStr != NULL)
        ReturnStr[0] = '\0';

    // return buffer
    return(ReturnStr);
}

This could also be condensed a little more:

char *InitStr(){
    char * ReturnStr;

    if ((ReturnStr = malloc(1)) != NULL)
        ReturnStr[0] = '\0';

    return(ReturnStr);
}

Here is another example of checking your allocation using your AddStr() function:

char *AddStr(char *StrObj1,char *StrObj2){
    void * ptr;
    ptr = realloc(StrObj1,(strlen(StrObj1) + strlen(StrObj2) + 1));
    if (ptr == NULL)
        return(StrObj1);
    StrObj1 = ptr;
    strcat(StrObj1, StrObj2);
    return(StrObj1);
}

You can slightly improve the runtime efficiency of this function be reducing the number of times you need to find the terminating NULL character in your strings:

char *AddStr(char *StrObj1,char *StrObj2){
    void * ptr;
    size_t len1;
    size_t len2;

    // determine length of strings
    len1 = strlen(StrObj1);
    len2 = strlen(StrObj2);

    // increase size of buffer
    if ((ptr = realloc(StrObj1, (len1 + len2 + 1))) == NULL)
        return(StrObj1);
    StrObj1 = ptr;

    // this passes a pointer which references the terminating '\0' of
    // StrObj1. This makes the string appear to be empty to strcat() which
    // in turn means that it does not compare each character of the string
    // trying to find the end. This is a minor performance increase, however if
    // running lots of string operations in a high iteration program, the combined
    // affect could be substantial. 
    strcat(&StrObj1[len1], StrObj2);

    return(StrObj1);
}

You can complete your last function without the while loop:

char *JoinStr(const char *fmt, ...)
{

   int len;
   char * str;
   void * ptr;
   va_list ap;

   // start with a small allocation to pass to vsnprintf()
   if ((str = malloc(2)) == NULL)
      return(NULL);
   str[0] = '\0';

   // run vsnprintf to determine required length of string
   va_start(ap, fmt);
      len = vsnprintf(str, 2, fmt, ap);
   va_end(ap);

   if (len < 2)
      return(str);

   // allocate enound space for entire formatted string
   len++;
   if ((ptr = realloc(str, ((size_t)len))) == NULL)
   {
      free(str);
      return(NULL);
   };

   // format string
   va_start(ap, fmt);
   vsnprintf(str, len, fmt, ap);
   va_end(ap);

   return(str);
}