Re: Nonstatic member example?
On Dec 31, 8:25 am, Rahul <sam_...@yahoo.co.in> wrote:
On Dec 31, 9:36 am, Juha Nieminen <nos...@thanks.invalid> wrote:
fl wrote:
There is a question about nonstatic member. C++ primer says: A
nonstatic member is restricted to being declared as a pointer or
reference to an object of its class. It only gives an example of
pointer *b.
class Bar {
public:
private:
static Bar a; // OK
Bar *b; // OK
Bar c; // error
My question is how a nonstatic member is declared as a
reference to an object of its class. Because a reference
is legal only after the original variable has been
declared, where is the original object? I feel it is
really bizarre. Could you give me an example? Thanks in
advance.
References and pointers can be created from pre-declared (ie.
incomplete) types.
The correct terminology is "incomplete type". A class type is
known as soon as it is declared, i.e. immediately after the name
of the class in either a declaration or a definition. The class
type is only complete after the final closing } of the
definition.
. It's not necessary to have the full declaration of
the type in order to create a reference or pointer of that
type.
Yes and no. I think that Rahul's problem was more along the
lines of:
class Foo
{
Foo& myFoo ;
} ;
According to the standard, myFoo, here, is a definition (not a
declaration), so one would expect it to be initialized with an
object. Which isn't possible at this point in the program,
because the type Foo is still incomplete, and you cannot have
objects with incomplete types.
The reason, of course, is that the definition of myFoo is
actually a definition of an unspecified number of instances of
the reference; each instance only comes into being when the
constructor of Foo is called. At that point, Foo must be
complete (and the reference must have an initializer, in the
initialization list), or the code is ill formed. (Note that if
the definition of the constructor is given within the class
body, it is processed as if it were immediately following the
complete definition of the class, so even something like the
following is legal:
class Foo
{
public:
Foo() : myFoo( *this ) { }
Foo( Foo& parent ) : myFoo( parent ) {}
Foo& myFoo ;
}
(Note that if the class contains a reference to itself, the only
possible initialization for the first instance is to itself.
Class instances are created one after the other, there are no
null references, and the reference must refer to an "existing"
object.)
That is, for example, this is valid:
class A; // Incomplete type
void foo(const A&); // Ok
In your example "Bar" has implicitly been pre-declared,
and thus it's ok to create a reference of pointer to it,
even inside Bar's declaration.
Then how does a static member object work? The type is
incomplete even for that isn't it?
A declaration of a non-static data member in a class is a
definition, and requires a complete type. A declaration of a
static data member is not a definition, and so does not require
a complete type (although if the static data member is used, you
must provide a definition somewhere, and the type must be
complete when you provide that definition).
Note the different lifetimes (and storage durations) associated
with static and non-static members. A non-static member has the
same lifetime and storage duration as the containing instance,
and is only initialized (and only requires a complete type) when
the containing instance is initialized. A static member has
static lifetime and storage duration, and is initialized during
static initialization, very much as if it were a variable
declared at namespace scope.
--
James Kanze (GABI Software) email:james.kanze@gmail.com
Conseils en informatique orient=E9e objet/
Beratung in objektorientierter Datenverarbeitung
9 place S=E9mard, 78210 St.-Cyr-l'=C9cole, France, +33 (0)1 30 23 00 34