C++ class design problem

Question

I have a class that executes the MSNP15 protocol. The protocol requires clients to perform frequent connection/disconnection to various servers like the dispatch server, login server and the switchboard server.

I decided to store the protocol related variables ( like ticket tokens, nonce etc ) as static member variables in a utility class like below:

class MsnUtility
    {
    public:
     static void SetChallengeStringL ( const char *string );

     static const char* GetChallengeString ( );

     static void SetContactTicketL ( const char *ticket );

     static const char* GetContactTicket ( );

    private:

     MsnUtility();

 static char *iChallengeString;

     static char *iContactTicket;
    };

The static variables above are initialized to NULL at startup and then newed when the tokens become available as the protocol executes.

Since I don't have access to C++ standard library ( as I am developing on Symbian S60 platform ) I cannot use the string library. Will the allocated character pointers be freed when the program exits or is there any other mechanism by which I could ensure they are freed.

I am also open to alternative design suggestions.

Answer 1

I don't think u need to worry about leaks after exit. Also If you are thinking about leak during the program lifetime, Go for singleton with reference counting.

Answer 2

If you allocate the memory, then you are the one who must release it. Since the members are static, they do not belong to any instance of the class. So you will have to ensure that the memory is released after the last possible use of the character pointers. This is often very difficult to determine.

I think a better idea in this case would be to have a singleton-class with all the needed tokens. Make this class globally accessible, provide necessary setters\getters for token-manipulation. Then when the dtor of the singleton class is called at program exit, you can de-alllocate the memory.

Something on the following lines :-

class TokenDict  {
public:
  static TokenDict& instance() {
    static TokenDict instance;
    return instance;
  }
  // getters \ setters for tokens
  void setToken(char* tptr) {
    if(token1)
      delete[] token1;
    // allocate memory for new token here
    token1 = new char[strlen(tptr) + 1];
    // copy tptr into token1
  }
  char const* getToken() const { return token1; }
private:
   ~TokenDict()
  {
    delete[] token1;
  }
  TokenDict() : token1(0) // ctor hidden
  { }
  TokenDict(TokenDict const&); // copy ctor hidden
  TokenDict& operator=(TokenDict const&); // assign op. hidden
  char* token1;
};

Answer 3

If you're going to use multiple instances of the class MsnUtility, please note, that as some of it's fields are static - basically all instances of it will be the same. This is called a Singleton - and is probably not what you were going for.

Answer 4

Why do you need a class if all the variables are static? If you want only one instance of the class, then consider making it a singleton. Then you can use the constructor and destructor to manage memory. I re-designed the class as a singleton:

class MsnUtility
{
public:
  static MsnUtility& Instance()
  {
    return instance;
  }
public:
  void SetChallengeStringL(const char* cstring)
  {
    if (iChallengeString) delete[] iChallengeString;
    iChallengeString = new char[strlen(cstring) + 1];
    strcpy(iChallengeString, cstring);
  }
  const char* GetChallengeString() const 
  {
    return iChallengeString;
  }
  void SetContactTicketL(const char* ticket)
  {
    if (iContactTicket) delete[] iContactTicket;
    iContactTicket = new char[strlen(ticket) + 1];
    strcpy(iContactTicket, ticket);
  }
  const char* GetContactTicket() const
  {
    return iContactTicket;
  }
private:
  MsnUtility() : iChallengeString(0), iContactTicket(0) { }
  ~MsnUtility()
  {
    if (iChallengeString) delete[] iChallengeString;
    if (iContactTicket) delete[] iContactTicket;
  } 
  char* iChallengeString;
  char* iContactTicket;
  static MsnUtility instance;
};

You can use the class like this:

// test.cpp

#include <iostream> // or whatever is available on your development platform.
#include "MsnUtility.h"

MsnUtility MsnUtility::instance;

int
main()
{
  MsnUtility& u = MsnUtility::Instance();
  u.SetContactTicketL("ticket");
  u.SetChallengeStringL("ch");
  std::cout << u.GetContactTicket() << ", " << u.GetChallengeString() << '\n';
  return 0;
}

Answer 5

I think you can look into Qt Tower project, it is still in early stages but it has a rich class library which includes UI as well.