Style (or otherwise?) question: creating temporary to invoke function

[jeffc]

Let's say you're in some function , and you want to accomplish some task x
that is provided for you by a class, A.
Which of these do you prefer, and is there a technical reason for it? (This
is actually the sort of thing that might be
provided for with a static class function, but one is not provided in this
case - an instance must be created.)

void f()
{
A a;
a.x();

A* p = new A();
p->x();
delete p;

A().x();
}

[E. Robert Tisdale]

jeffc wrote:

Let's say you're in some function and you want to accomplish
some task x that is provided for you by a class, A.
Which of these do you prefer, and is there a technical reason for it?
(This is actually the sort of thing that might be provided for
with a static class function,
but one is not provided in this case - an instance must be created.)
void f(void) {
A a;
a.x(); // OK

A* p = new A();
p->x();
delete p; // Never!

A().x(); // Best
}

Leaving a reference lying around
to an object that should never be reference again
is an invitation for trouble.
If some other programmer (meaning you after a while) maintaining f()
doesn't realize that the object to which p points has been deleted
and decides to add code to modify the object through p,
The function may or may not exhibit the expected behavior
and the bug may be very difficult to detect and fix.

[Ian]

jeffc wrote:

Let's say you're in some function , and you want to accomplish some task x
that is provided for you by a class, A.
Which of these do you prefer, and is there a technical reason for it? (This
is actually the sort of thing that might be
provided for with a static class function, but one is not provided in this
case - an instance must be created.)

void f()
{
A a;
a.x();
Fine, a on stack.
A* p = new A();
p->x();
delete p;
Has to call new and allocate p from heap, OTT.
A().x();
Fine and concise!

Ian
}

[Ioannis Vranos]

"jeffc" <no****@nowhere .com> wrote in message
news:40******** @news1.prserv.n et...

Let's say you're in some function , and you want to accomplish some task x
that is provided for you by a class, A.
Which of these do you prefer, and is there a technical reason for it? (This is actually the sort of thing that might be
provided for with a static class function, but one is not provided in this
case - an instance must be created.)

void f()
{
A a;
a.x();

A* p = new A();
p->x();
delete p;

Do the second if for some reason you can't do the first.

A().x();

Do this paranoid stuff if for some reason you cannot do the previous two.


Ioannis Vranos

[Kevin Goodsell]

jeffc wrote:

Let's say you're in some function , and you want to accomplish some task x
that is provided for you by a class, A.
Which of these do you prefer, and is there a technical reason for it? (This
is actually the sort of thing that might be
provided for with a static class function, but one is not provided in this
case - an instance must be created.)

void f()
{
A a;
a.x();

A* p = new A();
p->x();
delete p;

A().x();
}

If I wanted to do something like this, I imagine I'd ask myself, "Should
A::x() be static?"

-Kevin
--
My email address is valid, but changes periodically.
To contact me please use the address from a recent posting.

[jeffc]

"Ioannis Vranos" <iv*@guesswh.at .emails.ru> wrote in message
news:c5******** **@ulysses.noc. ntua.gr...

"jeffc" <no****@nowhere .com> wrote in message
news:40******** @news1.prserv.n et...

Let's say you're in some function , and you want to accomplish some task x that is provided for you by a class, A.
Which of these do you prefer, and is there a technical reason for it?

(This

is actually the sort of thing that might be
provided for with a static class function, but one is not provided in this case - an instance must be created.)

void f()
{
A a;
a.x();

A* p = new A();
p->x();
delete p;

Do the second if for some reason you can't do the first.

A().x();

Do this paranoid stuff if for some reason you cannot do the previous two.

There was nothing paranoid about it - merely succinctness. Which is not to
say I prefer succinctness over clarity. In fact, in the specific situation
I'm looking at, there is a parameter list that's long (3 very long parameter
names) so that the statement will span multiple lines. Therefore I don't
think I'll use the last technique, because I think the actual function call
(which is an extremely short name) will get lost in the soup.

[jeffc]

"Kevin Goodsell" <us************ *********@never box.com> wrote in message
news:8d******** **********@news read2.news.pas. earthlink.net.. .

If I wanted to do something like this, I imagine I'd ask myself, "Should
A::x() be static?"

You didn't read carefully :-)

[Andrey Tarasevich]

jeffc wrote:

Let's say you're in some function , and you want to accomplish some task x
that is provided for you by a class, A.
Which of these do you prefer, and is there a technical reason for it? (This
is actually the sort of thing that might be
provided for with a static class function, but one is not provided in this
case - an instance must be created.)

void f()
{
A a;
a.x();

A* p = new A();
p->x();
delete p;

A().x();
}

If class 'A' doesn't have any internal state or you don't care about
that state, then

A().x();

is the best way to do it. Otherwise, use

A a;
a.x();

--
Best regards,
Andrey Tarasevich

[Andrey Tarasevich]

Kevin Goodsell wrote:

...
If I wanted to do something like this, I imagine I'd ask myself, "Should
A::x() be static?"
...

Yes, by of 'x' happens to be 'operator ()' then you are out of luck,
since 'operator ()' cannot be static.

--
Best regards,
Andrey Tarasevich

[Ioannis Vranos]

"jeffc" <no****@nowhere .com> wrote in message
news:40******** @news1.prserv.n et...

"Ioannis Vranos" <iv*@guesswh.at .emails.ru> wrote in message
news:c5******** **@ulysses.noc. ntua.gr...

"jeffc" <no****@nowhere .com> wrote in message
news:40******** @news1.prserv.n et...

Let's say you're in some function , and you want to accomplish some

task

x that is provided for you by a class, A.
Which of these do you prefer, and is there a technical reason for it? (This

is actually the sort of thing that might be
provided for with a static class function, but one is not provided in this case - an instance must be created.)

void f()
{
A a;
a.x();

A* p = new A();
p->x();
delete p;

Do the second if for some reason you can't do the first.

A().x();

Do this paranoid stuff if for some reason you cannot do the previous

two.
There was nothing paranoid about it - merely succinctness.
I did not mean to insult you, i spoke a bit freely. Let me rephrase: Do this
temporary object stuff ...

Which is not to
say I prefer succinctness over clarity. In fact, in the specific situation I'm looking at, there is a parameter list that's long (3 very long parameter names) so that the statement will span multiple lines. Therefore I don't
think I'll use the last technique, because I think the actual function call (which is an extremely short name) will get lost in the soup.

Well if the long function names bother you, you can do friend functions in
the style:
inline whatever_the_me thod_returns function1(A &x, whatever_parame ter y)
{
return x.the_long_vers ion_member_func tion(y);
}
// ...

A a;

function1(a, y);
Of course there are millions of things you can do like,

class capsule: public A
{
public:
// Your new short-name versions of functions accessing the old ones
// with *this
};
or
class capsule
{

public:
int some_func()
{
A a;

return a.x();
}
};

or

class capsule
{
A a;
// A *a;

public:
int some_func() { // ... }
// ...
};
// ...


Ioannis Vranos