Re: B const * array[ ] in gobal
On Feb 8, 1:55 pm, soft wind <soft_w...@nifty.com> wrote:
I have a problem about an object ( B const * array[ ] ) in
global. Please see source program below.
I provide B * const array [ ] in global scope in my first try,
but their lifetime seems to be already end when the program
goes to the enrty of main function.
why is it so ?
I usually provide char const * array[ ] in global and goes
well. In which page does the standard describe about
lifetime in this case ?
Maybe '3.8 Object lifetime", but which phrases are applied in this
case?
In my second try, it goes well but another structure (class)
is required. Is there any better way to provide B * pointer
to handle late binding ?
------------------------------------------------------------------
#include <string>
#include <iostream>
using std::string;
using std::cout;
class B {
public:
B( string str ) : str_m( str ) { }
string get_str( void ) const { return str_m; }
virtual int fnc( void ) const = 0;
virtual ~B( ) { }
private:
std::string str_m;
};
class D : public B {
public:
D( string str ) : B( str ) { }
virtual int fnc( void ) const { return 1; }
};
struct Create_B {
string str_m;
B * (*fnc)( string str );
};
B * create_D( string str )
{
return new D( str );
}
B const * list_0[ ] = {
& D( "D0" ),
This shouldn't compile. I don't see any user defined overload
of D::operator&, so & is the built in operator, which requires
an lvalue.
If it does compile, you're using an implementation specific
extention, not C++, and you'll have to verify in the
implementation documentation what it means with regards to
lifetime of objects.
(Personally, I'd be very suspicious of a compiler with such
extensions, as it suggests that the people who wrote the
compiler don't understand C++.)
};
D const list_1[ ] = {
D( "D1" ),
};
Create_B list_2[ ] = {
{ "D2", &create_D },
};
int main( void )
Just a nit, but the void marks you as a C programmer, and gives
the impression that you don't know C++.
{
// My first try, but fails
s = list_0[ 0 ]->get_str( );
What is "s"? I don't see it declared anywhere.
As for the rest, see your compiler documentation; the
initialization of list_0 isn't C++, but some compiler specific
extention, so only the compiler documentation can tell you what
to expect.
cout << s << "\n";
// just for checking what is wrong with the first try
string s;
s = list_1[ 0 ].get_str( );
cout << s << "\n";
This is well defined behavior: it should call the get_str
function on a copy of the D object used to initialize list_1.
// My second try runs without error,
// but another class 'Create_B' is required
B * p = list_2[ 0 ].fnc( list_2[ 0 ].str_m );
s = p->get_str( );
cout << s << "\n";
This is also legal, but has distinctly different semantics than
the first two, since it creates a new object on the heap.
return 0;
}
--
James Kanze