How can I keep reference to an input parameter of a function?

[Allerdyce.John]

I have a function in a class:
void A::aFunction (B& b) {
// do something
....
}

void A::anotherFunction() {
// need a reference of B again.

}

my question is how can I create an attriubte of A which can hold B
after A::aFunction() is called?
I can't create a reference of B as an attribute of A (since aFunciton
is not called during constructor of A).

Thanks for any idea.

 

[Gianni Mariani]

I have a function in a class:
void A::aFunction (B& b) {
// do something
...
}

void A::anotherFunction() {
// need a reference of B again.

}

my question is how can I create an attriubte of A which can hold B
after A::aFunction() is called?
I can't create a reference of B as an attribute of A (since aFunciton
is not called during constructor of A).

Thanks for any idea.

Using a pointer ... somthing like so ?

struct B;

struct A
{

B * m_b;
A()
: m_b(0)
{}

void aFunction (B& b)
{
m_b = &b;
}

void anotherFunction()
{
assert( m_b );
B & b = * m_b;
}
};

 

[Markus Moll]

Hi

I have a function in a class:
void A::aFunction (B& b) {
// do something
...
}

void A::anotherFunction() {
// need a reference of B again.

}

my question is how can I create an attriubte of A which can hold B
after A::aFunction() is called?
I can't create a reference of B as an attribute of A (since aFunciton
is not called during constructor of A).

There are reference wrappers (boost::reference_wrapper), or you could write
one yourself. It's basically struct wrapper { B& ref; wrapper(B& ref) :
ref(ref) {} };
But I don't like the whole idea of caching some B in A, as it relies on the
user's first calling aFunction. Why not return some object from aFunction
on which you can invoke anotherFunction?

Markus

 

[Michiel.Salters]

I have a function in a class:
void A::aFunction (B& b) {
// do something
...
}

void A::anotherFunction() {
// need a reference of B again.

}

my question is how can I create an attriubte of A which can hold B
after A::aFunction() is called?

Do you really need it? What if the B object is destroyed after
A::aFunction
returns? What if aFunction is called twice? Which B is needed then?
You might be able to hold a copy of B. If it's designed properly, it
will have
a copy constructor if and only if you can copy it. Of course, that
means that
anotherFunction will work on a copy of b, but at least A can ensure the
lifetime of that copy.

A proper design would probably involve a smart pointer. Either
std::auto_ptr<B>,
boost::shared_ptr<B> or std::tr1::shared_ptr<B> could work.

HTH,
Michiel Salters

 

[Tomás]

posted:

I have a function in a class:
void A::aFunction (B& b) {
// do something
...
}

void A::anotherFunction() {
// need a reference of B again.

}

my question is how can I create an attriubte of A which can hold B
after A::aFunction() is called?
I can't create a reference of B as an attribute of A (since aFunciton
is not called during constructor of A).

Thanks for any idea.

Add the following to A:

class A
{
protected:

B* p_b;
};


Then write the functions as follows:


void A::aFunction (B& b)
{
p_b = &b;
}


Then to use it as a reference in another function:


void A::anotherFunction()
{
B& b = *p_b;

//Now we can use "b" as we please:

b.EatGrass();

FunctionThatTakesB( b );
}

-Tomás