ansi status of 'using'

[Mark Huppert]

Dear Colleagues

re: 'using' and the ANSI C++ standard

According to the ANSI C++ standard, is this a valid
way (disregarding whether it is 'naughty') of converting a
public method in the base class into a private method in the child class?
My g++ compiler ignores this without comment.

class parent{
public:
double length(double num) {return num; }
};

class child: public parent {
public:
double hiding(double num) {return length(num);}
private:
using parent::length;
};

ie, equivalent to:
private:
double length(double num) {return parent::length(num); }

Mark Huppert

[Ioannis Vranos]

"Mark Huppert" <du******@netspeed.com.au> wrote in message
news:40********@mail.netspeed.com.au...

Dear Colleagues

re: 'using' and the ANSI C++ standard

According to the ANSI C++ standard, is this a valid
way (disregarding whether it is 'naughty') of converting a
public method in the base class into a private method in the child class?
My g++ compiler ignores this without comment.

class parent{
public:
double length(double num) {return num; }
};

class child: public parent {
public:
double hiding(double num) {return length(num);}
private:
using parent::length;
};

ie, equivalent to:
private:
double length(double num) {return parent::length(num); }

No, but why doing this? You can do:
class parent{
public:
double length(double num) {return num; }
};

class child: private parent {
public:
double hiding(double num) {return length(num);}
};


Regards,

Ioannis Vranos

[Jeff Schwab]

Mark Huppert wrote:

According to the ANSI C++ standard, is this a valid
way (disregarding whether it is 'naughty') of converting a
public method in the base class into a private method in the child class?
No.
My g++ compiler ignores this without comment.
Because it's doing something valid, just not what you think it's doing.
class parent{
public:
double length(double num) {return num; }
};

class child: public parent {
public:
double hiding(double num) {return length(num);}
private:
using parent::length;
};

ie, equivalent to:
private:
double length(double num) {return parent::length(num); }

Are you sure about that? There is no way to make publicly inherited
members "more private." Try this.

class parent{
public:
double length(double num) {return num; }
};

class child: public parent {
public:
double hiding(double num) {return length(num);}
private:
using parent::length;
};

int main ( )
{
child c;

c.length( 3.0 );
}

[Jacek Dziedzic]

Mark Huppert wrote:

Dear Colleagues

re: 'using' and the ANSI C++ standard

According to the ANSI C++ standard, is this a valid
way (disregarding whether it is 'naughty') of converting a
public method in the base class into a private method in the child class?
My g++ compiler ignores this without comment.

class parent{
public:
double length(double num) {return num; }
};

class child: public parent {
public:
double hiding(double num) {return length(num);}
private:
using parent::length;
};

ie, equivalent to:
private:
double length(double num) {return parent::length(num); }

The using declaration does "bring the otherwise hidden names
from the base class into scope of the derived class", but I don't
think it does matter whether you put it in the private or protected
or public section. Therefore I'd say it is *not* equivalent.

Hope I got it right this time :)

You could visit
http://www.parashift.com/c++-faq-lit....html#faq-23.6
for an example of meaningful usage of 'using' within a class.

HTH,
- J.

[Ivan Vecerina]

"Mark Huppert" <du******@netspeed.com.au> wrote in message
news:40********@mail.netspeed.com.au...

Dear Colleagues

re: 'using' and the ANSI C++ standard

According to the ANSI C++ standard, is this a valid
way (disregarding whether it is 'naughty') of converting a
public method in the base class into a private method in the child class?
My g++ compiler ignores this without comment. [...]

'using' can only *increase* the visibility of an inherited member
(i.e. make a private member public), but not restrict it.
class parent{
public:
double length(double num) {return num; }
};

class child: public parent {
public:
double hiding(double num) {return length(num);}
private:
using parent::length;
};

You cannot do this, and it wouldn't really make sense:
child c;
c.length(); // you want this to be an error?
parent& p = c; // but this is legal and implicit
p.length(); // legal, and no cast needed...

What you can do is privately derive from parent.
Or even better, use *containment* instead
(store child as a data member of parent).
Regards,
Ivan
--
http://ivan.vecerina.com/contact/?subject=NG_POST <- e-mail contact form
Brainbench MVP for C++ <> http://www.brainbench.com