Ad:

C++ Discussion Thread
Marked Solved
Views: 636

Jun 12th, 2009

Static Objects of class within that class

Expand Post »

I'm wondering if this is even possible in C++. Here's what I did in java a while back:

java Syntax (Toggle Plain Text)
class Suit {
  public static Suit Hearts = new Suit("Hearts");
  public static Suit Clubs = new Suit("Clubs");
  public static Suit Diamonds = new Suit("Diamonds");
  public static Suit Spades = new Suit("Spades");
  private String value;
 
  private Suit(String suit)
  {
    value = suit;
  }
 
  public String getValue()
  {
    return value;
  }
}
class Suit {
  public static Suit Hearts = new Suit("Hearts");
  public static Suit Clubs = new Suit("Clubs");
  public static Suit Diamonds = new Suit("Diamonds");
  public static Suit Spades = new Suit("Spades");
  private String value;
 
  private Suit(String suit)
  {
    value = suit;
  }
 
  public String getValue()
  {
    return value;
  }
}

After trying many ways to do this in C++, I keep getting back to the error that:
only static const integral data members can be initialized within a class.
I know I could accomplish something similar with an enum Suits {Hearts, Spades, Diamonds, Clubs} , but I really would like to have the string associated with it.

Does anybody have any idea how to do this?

Similar Threads

chaines51

Reputation Points: 10

Solved Threads: 5

Junior Poster in Training

Offline

54 posts
since Jun 2009

Permalink

Jun 12th, 2009

Re: Static Objects of class within that class

Of course, all possible in C++

That's an improvisation:

C++ Syntax (Toggle Plain Text)
/// suite.h (class Suite definition)
class Suite
{
public:
    Suite() {}
    Suite(const Suite& suit):value(suit.value) {}
    static const Suite 
        Hearts,
        Clubs,
        Diamonds,
        Spades;
    /// that's all, add some methods...
    const string& str() const { return value; }
    /// add some syntax sugar:
    operator bool() const { return !value.empty(); }
    bool operator ==(const Suite& suit) {
        return value == suit.str();
    }
    bool operator !=(const Suite& suit) {
        return value != suit.str();
    }
protected:  // there are four colours only
    Suite(const char* suit):value(suit) {}
private:
    string value;
};
inline // add stream output support
ostream& operator <<(ostream& os, const Suite& suit) {
    return os << suit.str();
}
/// suite.cpp (class Suite implementation)
const Suite 
    Suite::Hearts("Hearts"),
    Suite::Clubs ("Clubs"),
    Suite::Diamonds("Diamonds"),
    Suite::Spades("Spades")
    ;
/// test.cpp:
/// more syntax sugar for lazies
const Suite& 
    Hearts = Suite::Hearts,
    Clubs  = Suite::Clubs,
    Diamonds = Suite::Diamonds,
    Spades = Suite::Spades
    ;
 
int main()
{
    Suite suit;
    suit = Spades;
    Suite card(Clubs);
    if (card && suit == Spades)
        cout << suit << '\t' << card << endl;
    return 0;
}
/// suite.h (class Suite definition)
class Suite
{
public:
    Suite() {}
    Suite(const Suite& suit):value(suit.value) {}
    static const Suite 
        Hearts,
        Clubs,
        Diamonds,
        Spades;
    /// that's all, add some methods...
    const string& str() const { return value; }
    /// add some syntax sugar:
    operator bool() const { return !value.empty(); }
    bool operator ==(const Suite& suit) {
        return value == suit.str();
    }
    bool operator !=(const Suite& suit) {
        return value != suit.str();
    }
protected:  // there are four colours only
    Suite(const char* suit):value(suit) {}
private:
    string value;
};
inline // add stream output support
ostream& operator <<(ostream& os, const Suite& suit) {
    return os << suit.str();
}
/// suite.cpp (class Suite implementation)
const Suite 
    Suite::Hearts("Hearts"),
    Suite::Clubs ("Clubs"),
    Suite::Diamonds("Diamonds"),
    Suite::Spades("Spades")
    ;
/// test.cpp:
/// more syntax sugar for lazies
const Suite& 
    Hearts = Suite::Hearts,
    Clubs  = Suite::Clubs,
    Diamonds = Suite::Diamonds,
    Spades = Suite::Spades
    ;

int main()
{
    Suite suit;
    suit = Spades;
    Suite card(Clubs);
    if (card && suit == Spades)
        cout << suit << '\t' << card << endl;
    return 0;
}

Last edited by ArkM; Jun 12th, 2009 at 5:11 am.

ArkM

Reputation Points: 1234

Solved Threads: 347

Postaholic

Offline

2,001 posts
since Jul 2008

Permalink

Jun 12th, 2009

Re: Static Objects of class within that class

OK.

c++ Syntax (Toggle Plain Text)
Suite(const Suite& suit):value(suit.value) {}
Suite(const Suite& suit):value(suit.value) {}

what exactly does that line MEAN? Specifically the ...:value(suit.value){} part...

chaines51

Reputation Points: 10

Solved Threads: 5

Junior Poster in Training

Offline

54 posts
since Jun 2009

Permalink

Jun 12th, 2009

Re: Static Objects of class within that class

This part is so called ctor-initializer-list. In C++ it's a preferred way to initialize class members and the only method to pass constructor arguments to base class(es) constructors (the last feature is not used here). Alas, it's impossible to initialize non-integral types static data members in ctor-initializer-list. That's why we do it separately in lines 32-37.

So

C++ Syntax (Toggle Plain Text)
Suite(const Suite& suit):value(suit.value) {}
Suite(const Suite& suit):value(suit.value) {}

is the class Suite copy constructor: it creates a Suite object from another object of the same type.

The point is that we must define all needed constructors (default constructor - line #5, copy constructor - line #6) if a class has user-defined constructor (see line #23).

Take into account that I don't want to allow users to construct arbitrary Suite objects (like Suite card("Cheat") ). That's why the constructor defined in line #23 is protected. Now we can initialize four static Suite objects (lines 32-37) and construct all others via the copy constructor.

To allow Suite object arrays we need Suite default constructor (a constructor without parameters).

Oh, as usually {} means copy constructor body (a constructor is a member function). It's inline constructor - no need to call any real functions to construct a Suite object with this constructor.

More questions?..

Last edited by ArkM; Jun 12th, 2009 at 1:45 pm.

ArkM

Reputation Points: 1234

Solved Threads: 347

Postaholic

Offline

2,001 posts
since Jul 2008

Permalink

Jun 12th, 2009

Re: Static Objects of class within that class

In addition:
Change lines 40-45 in my code above to

C++ Syntax (Toggle Plain Text)
/// more syntax sugar for lazies
const Suite 
    &Hearts = Suite::Hearts,
    &Clubs  = Suite::Clubs,
    &Diamonds = Suite::Diamonds,
    &Spades = Suite::Spades
    ;
/// more syntax sugar for lazies
const Suite 
    &Hearts = Suite::Hearts,
    &Clubs  = Suite::Clubs,
    &Diamonds = Suite::Diamonds,
    &Spades = Suite::Spades
    ;

Probably it's more effective...
I hope you understand that it's an optional code...

ArkM

Reputation Points: 1234

Solved Threads: 347

Postaholic

Offline

2,001 posts
since Jul 2008

Permalink

Jun 12th, 2009

Re: Static Objects of class within that class

No sir, I understand the rest of it

But, just to make sure: Those constructors could have been written like this:

c++ Syntax (Toggle Plain Text)
Suite(const Suite & suit)
{
  value = suit.value;
}
Suite(const char* suit)
{
  value = suit
}
Suite(const Suite & suit)
{
  value = suit.value;
}
Suite(const char* suit)
{
  value = suit
}

but it's just more efficient the other way, because it doesn't initialize value first? Would it actually initialize value first anyway, since it isn't an object?

Thanks a million.

chaines51

Reputation Points: 10

Solved Threads: 5

Junior Poster in Training

Offline

54 posts
since Jun 2009

Permalink

Jun 12th, 2009

Re: Static Objects of class within that class

Your constructor variant with assignments has the same effect as mine. However as usually assignments in constructors (or even anywhere) are less effective than initialization with ctor-initializers (and are less clear). Yes, formally in your case the compiler initializes an empty string member then creates a temporary string object (for Suite(const char*) constructor) and performs assignment after that. Besides that, ctor-initializer semantically (and pragmatically) directs a (good) compiler to the best optimization of constructor codes.

That's why ctor-initiaslizer-lists are better than assignments. Whenever you have a choice, select ctor-initializer. Don't forget: a constructor is intended for an object initialization.

ArkM

Reputation Points: 1234

Solved Threads: 347

Postaholic

Offline

2,001 posts
since Jul 2008

This thread is solved

Either the thread starter or a moderator has marked this thread as solved. You can most likely trust the responses and answers given. There is most likely no reason for any further responses to be posted here. If you have a related question, please start a new thread in this forum instead.

This thread is more than three months old

No one has posted to this discussion for at least three months. Please let old threads die and do not reply to them unless you feel you have something new and valuable to contribute that absolutely must be added to make the discussion complete. Otherwise, please start a new thread in this forum instead.

Previous Thread in C++ Forum Timeline: deleting the repeated numbers

Next Thread in C++ Forum Timeline: Graphical Dos Interface

DaniWeb Message

Cancel Changes

User Name
Password