Non-initialized class

[ejstans]

Hello,

I encountered something unfamiliar to me today and I would like some
clarifications. Unfortunately I don't have access to a standard but
even if I did, I'm not even sure if I could understand it well enough
to answer my question...

Here's the deal: without instantiating the class, the code in question
calls both static and non-static member functions like this:

class foo {
public:
static void bar() { std::cout << "bar" << std::endl; }
void bar2() { std::cout << "bar2" << std::endl; }
};

void
func(foo* f)
{
f->bar();
f->bar2();
}

int
main()
{
func(NULL);
return 0;
}

Is this allowed? And if it is, does a situation exist where it would
be an advisable way of doing things?

 

[Erik Wikström]

Hello,

I encountered something unfamiliar to me today and I would like some
clarifications. Unfortunately I don't have access to a standard but
even if I did, I'm not even sure if I could understand it well enough
to answer my question...

Here's the deal: without instantiating the class, the code in question
calls both static and non-static member functions like this:

class foo {
public:
static void bar() { std::cout << "bar" << std::endl; }
void bar2() { std::cout << "bar2" << std::endl; }
};

void
func(foo* f)
{
f->bar();
f->bar2();
}

int
main()
{
func(NULL);
return 0;
}

Is this allowed? And if it is, does a situation exist where it would
be an advisable way of doing things?

No, this is not allowed. The reason it works is because you are not
trying to access any class member and the way the compiler generates to
code. It is never advisable to do something like this.

Note though that you can always access static member functions without
an object using the foo::bar() notation.

 

[Erik Wikström]

That is, "No" to calling non-static member functions without an object.
Static member functions are fine.

But you would have to use the Class::Function() notation right? I assume
that that 9.4/2 applies to static member functions as well, more
specifically: "A static member may be referred to using the class member
access syntax, in which case the object-expression is evaluated."

 

[ejstans]

No, this is not allowed. The reason it works is because you are not
trying to access any class member and the way the compiler generates to
code. It is never advisable to do something like this.

Note though that you can always access static member functions without
an object using the foo::bar() notation.

Thanks for the quick replies (that goes to everyone of course).

I've got the gist of the matter, but just to cross all the i's and dot
all the t's, is it in fact valid according to the standard to call a
static member function through a NULL pointer? But invalid (undefined
result?) to do so with a non-static function, even if it doesn't touch
any member data? This is just to satisfy my curiousity, I don't like
this construction and don't plan on using it myself...

 

[ejstans]

No, this is not allowed. The reason it works is [..]

<rant>
The behaviour is undefined.  Any attempt to explain why undefined
behaviour actually creates an illusion (yes, an illusion) of a working
program only contributes to the confusion.  Now the OP might think,
"it's OK if <blahblah>".  But the actual mantra should be "no, it's not
OK, ever".  It's similar to "When/Why is it OK to point an unloaded
weapon at your friend's head?"  Well, it's NOT.  Ever.  So, the premise
here ("it works") is wrong.  It does NOT work.  It's not defined to.
</rant>

Heh! Thanks! I was after this kind of clear-cut answer; that's why I
persisted with the second question as to the actual "legality" of it,
unfortunately posted before I could see your reply.

 

[Michael]

Hello,

I encountered something unfamiliar to me today and I would like some
clarifications. Unfortunately I don't have access to a standard but
even if I did, I'm not even sure if I could understand it well enough
to answer my question...

Here's the deal: without instantiating the class, the code in question
calls both static and non-static member functions like this:

class foo {
public:
static void bar() { std::cout << "bar" << std::endl; }
void bar2() { std::cout << "bar2" << std::endl; }
};

void
func(foo* f)
{
f->bar();
f->bar2();
}

int
main()
{
func(NULL);
return 0;
}

Is this allowed? And if it is, does a situation exist where it would
be an advisable way of doing things?

In this case, you are trying to dereference a NULL pointer, which will
produce undefined behaviour.

 

[Old Wolf]

I've got the gist of the matter, but just to cross all the i's and dot
all the t's, is it in fact valid according to the standard to call a
static member function through a NULL pointer?

No.