Defining a constant in a class

[Joe Van Dyk]

class Foo
{
private:
const std::string type_("FOO_TYPE");
};

I'd like to do something like that, but I don't think that's allowed.
Do I need to put type_ inside each of Foo's ctor initialization list?

[Ian Collins]

Joe Van Dyk wrote:

class Foo
{
private:
const std::string type_("FOO_TYPE");
};

I'd like to do something like that, but I don't think that's allowed. Do
I need to put type_ inside each of Foo's ctor initialization list?

You can use a static member, or in this case it might be easier to use a
member function:

std::string type() const { return "FOO_TYPE"; }

--
Ian Collins.

[Chris ( Val )]

Joe Van Dyk wrote:

class Foo
{
private:
const std::string type_("FOO_TYPE");
};

I'd like to do something like that, but I don't think that's allowed.
Do I need to put type_ inside each of Foo's ctor initialization list?

What's wrong with initialising a constant in a default constructor,
or even an overloaded one as follows:?

class Foo
{
private:
const std::string type_;
public:
Foo( const std::string& foo_type ) : type_( foo_type ) {}
};

int main()
{
Foo F( "FOO_TYPE" );

// ...

Cheers,
Chris Val

[Joe Van Dyk]

Ian Collins wrote:

Joe Van Dyk wrote:

class Foo
{
private:
const std::string type_("FOO_TYPE");
};

I'd like to do something like that, but I don't think that's allowed. Do
I need to put type_ inside each of Foo's ctor initialization list?

You can use a static member, or in this case it might be easier to use a
member function:

std::string type() const { return "FOO_TYPE"; }

Hm... in what situation would I want to use your first suggestion (and
in what situation would I want to use your second suggestion)?

Thanks,
Joe

[Alf P. Steinbach]

* Joe Van Dyk:

Ian Collins wrote:

Joe Van Dyk wrote:

class Foo
{
private:
const std::string type_("FOO_TYPE");
};

I'd like to do something like that, but I don't think that's allowed. Do
I need to put type_ inside each of Foo's ctor initialization list?

You can use a static member, or in this case it might be easier to use a
member function:

std::string type() const { return "FOO_TYPE"; }

Hm... in what situation would I want to use your first suggestion (and
in what situation would I want to use your second suggestion)?

Using a static const data member is more work if you have to provide the
value in a header file and don't want it duplicated in every compilation
unit -- and if you do that (correctly, that is) then others may not
understand the code. ;-)

Also, a member function can be virtual, a static data member can't.

Thirdly, with a static data member of class type you run the risk of
initialization order fiasco, that it may be used before being initialized.

--
A: Because it messes up the order in which people normally read text.
Q: Why is it such a bad thing?
A: Top-posting.
Q: What is the most annoying thing on usenet and in e-mail?

[fcvcnet]

am I right?
for you constructor is not the default constructor.

[Salt_Peter]

context please?

fcvcnet wrote:

am I right?
for you constructor is not the default constructor.

He did not give you a default ctor.
If he had it would have looked like so:

class Foo
{
const std::string type_;
public:
Foo() : type_("FOO_TYPE") { }
Foo( const std::string& foo_type ) : type_( foo_type ) { }
};

[Joe Van Dyk]

Chris ( Val ) wrote:

Joe Van Dyk wrote:

class Foo
{
private:
const std::string type_("FOO_TYPE");
};

I'd like to do something like that, but I don't think that's allowed.
Do I need to put type_ inside each of Foo's ctor initialization list?

What's wrong with initialising a constant in a default constructor,
or even an overloaded one as follows:?

class Foo
{
private:
const std::string type_;
public:
Foo( const std::string& foo_type ) : type_( foo_type ) {}
};

int main()
{
Foo F( "FOO_TYPE" );

// ...

Cheers,
Chris Val

It would have to be repeated in each ctor then, right? And I think
duplication is the root of some evil.

[Victor Bazarov]

Joe Van Dyk wrote:

Chris ( Val ) wrote:

Joe Van Dyk wrote:

class Foo
{
private:
const std::string type_("FOO_TYPE");
};

I'd like to do something like that, but I don't think that's
allowed. Do I need to put type_ inside each of Foo's ctor
initialization list?

What's wrong with initialising a constant in a default constructor,
or even an overloaded one as follows:?

class Foo
{
private:
const std::string type_;
public:
Foo( const std::string& foo_type ) : type_( foo_type ) {}
};

int main()
{
Foo F( "FOO_TYPE" );

// ...

Cheers,
Chris Val

It would have to be repeated in each ctor then, right? And I think
duplication is the root of some evil.

If the string doesn't change depending on the constructor (or its args)
then why is the member non-static? And if it is, in fact, static by
nature, declare it such, and initialise in one place, no duplication of
code, and more, no duplication of data.

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask