Re: using keyword in C++
On 3/10/2011 8:52 AM, MJ_India wrote:
On Mar 10, 10:17 pm, Victor Bazarov<v.baza...@comcast.invalid> wrote:
On 3/10/2011 8:00 AM, MJ_India wrote:
struct foo { static const int bar = 0; };
int baz() {
using foo::bar; // [1]
return bar; // [2]
}
[1] is invalid in standard C++ because standard C++ allows _using_
keyword only in 3 ways (For namespace, a member of namespace or in
derived classes to avoid shadowing or to increase privateness of
inherited member)
To make statement [2] work without fully qualified name I need some
workaround(a reference or define).
I would like to see a reason to prefer
<some trick to bring foo::bar into scope>
return bar;
over
return foo::bar;
. Please provide it.
1. Okay, it is analogous to some_member over
a_namespace_name::some_member. (Which is allowed)
2. It can sometimes increase readability.
Use references. Like
const int& bar = foo::bar;
..
return bar;
There, I just increased readability. Or did I? How is hiding the
source of 'bar' symbol increasing readability? No, really. How?
My question is, what is the advantage of not allowing [1] as valid C++
grammar?
The advantage is simplification of the language.
I sometimes think allowing [1] may be useful in some scenarios
Name at least one, please.
There are 2 classes I can not change.
class CPdf {
public:
static const performance_parameter_01 = 0;
...
};
class CDoc {
public:
static const performance_parameter_01 = 100;
static const performance_parameter_02 = 200;
...
};
namespace default_parameter {
static const performance_parameter_01 = 50;
static const performance_parameter_02 = 250;
}
using namespace default_parameter;
result viewer(CPdf&pdf) {
using CPdf::performance_parameter_01;
...
TunePerformance(performance_parameter_01, performance_parameter_02);
...
}
result viewer(CDoc&doc) {
using CDoc::performance_parameter_01;
using CDoc::performance_parameter_02;
...
TunePerformance(performance_parameter_01, performance_parameter_02);
...
}
Which part of this is yours and which part can't you change?
I don't remember exact scenario, but it happened long back.
I was using some library and I felt if I can write some code like
above, it was more readable.
Well, readability in the eye of the beholder. Besides, there are other
ways to make the code more readable, like giving meaningful names to
variables.
But I ended up writing many big named classes, sub classes, final
members and many scope resolution operators because of the code layout
of that module writer and lack of using class_name::member.
The code was apparently awful to begin with (from your readability
standpoint). Adding a couple of scope resolution operators (qualifying
some names to help compiler resolve them) didn't really hurt it, did it?
V
--
I do not respond to top-posted replies, please don't ask