Velocity Reviews - Computer Hardware Reviews

Velocity Reviews > Newsgroups > Programming > C++ > typedef vs variable declaration inside a class

Reply
Thread Tools

typedef vs variable declaration inside a class

 
 
subramanian100in@yahoo.com, India
Guest
Posts: n/a
 
      06-26-2007
Consider the program

#include <iostream>

using namespace std;

class Test
{
public:
Test(Test_int c_value)
{
value = c_value;
}

typedef int Test_int;

private:
Test_int value;
};

int main()
{
Test t(100);

return 0;
}

Here I am getting compilation error for the line
Test(Test_int c_value)
because it uses Test_int type which is not known at that point and is
declared afterwards.

If I declare
typedef int Test_int;
before the the ctor, the compilation error goes. But the data member
'value' is used inside the ctor at which point the definition of the
variable is not known(it is defined later in the private section).

My doubt is why the compiler is unable to see the typedef declaration
for Type_int when it occurs later in the class; but it is able to see
the data member 'value' used in the ctor but which is actually defined
inside the private section later in the class.

Why are the typedef and variable definition inside the class treated
differently ?

Kindly explain

Thanks
V.Subramanian

 
Reply With Quote
 
 
 
 
John Harrison
Guest
Posts: n/a
 
      06-26-2007
http://www.velocityreviews.com/forums/(E-Mail Removed), India wrote:
> Consider the program
>
> #include <iostream>
>
> using namespace std;
>
> class Test
> {
> public:
> Test(Test_int c_value)
> {
> value = c_value;
> }
>
> typedef int Test_int;
>
> private:
> Test_int value;
> };
>
> int main()
> {
> Test t(100);
>
> return 0;
> }
>
> Here I am getting compilation error for the line
> Test(Test_int c_value)
> because it uses Test_int type which is not known at that point and is
> declared afterwards.
>
> If I declare
> typedef int Test_int;
> before the the ctor, the compilation error goes. But the data member
> 'value' is used inside the ctor at which point the definition of the
> variable is not known(it is defined later in the private section).
>
> My doubt is why the compiler is unable to see the typedef declaration
> for Type_int when it occurs later in the class; but it is able to see
> the data member 'value' used in the ctor but which is actually defined
> inside the private section later in the class.
>
> Why are the typedef and variable definition inside the class treated
> differently ?
>
> Kindly explain
>
> Thanks
> V.Subramanian
>


My understanding is that this rule exists to make life easier for
compiler writers. The C/C++ syntax is ambiguous (in the LALR(1) sense)
unless you know which names are typedefs and which names are just
ordinary identifiers. So special requirements are made of typedefs,
namely that you must declare them before you use them.

I read all this a long time ago, so don't take my word for it. Someone
else might have a better explanation.

john
 
Reply With Quote
 
 
 
 
ketan
Guest
Posts: n/a
 
      06-26-2007
Hi Subramanian,

Typedef is an alias for any valid type. It occupies the same namespace
as other identifiers and obeys the usual scope rules.

Applying scope rules once you declare typedef before ctor, you are
allowed to use typedef till the end of the class scope.
Hence it will work. But when you declare it after C'tor compile has
not still seen the typedef and hence does not know
the alias that you intend to use.

Hope this explains.
Ketan

On Jun 25, 9:49 pm, "(E-Mail Removed), India"
<(E-Mail Removed)> wrote:
> Consider the program
>
> #include <iostream>
>
> using namespace std;
>
> class Test
> {
> public:
> Test(Test_int c_value)
> {
> value = c_value;
> }
>
> typedef int Test_int;
>
> private:
> Test_int value;
>
> };
>
> int main()
> {
> Test t(100);
>
> return 0;
>
> }
>
> Here I am getting compilation error for the line
> Test(Test_int c_value)
> because it uses Test_int type which is not known at that point and is
> declared afterwards.
>
> If I declare
> typedef int Test_int;
> before the the ctor, the compilation error goes. But the data member
> 'value' is used inside the ctor at which point the definition of the
> variable is not known(it is defined later in the private section).
>
> My doubt is why the compiler is unable to see the typedef declaration
> for Type_int when it occurs later in the class; but it is able to see
> the data member 'value' used in the ctor but which is actually defined
> inside the private section later in the class.
>
> Why are the typedef and variable definition inside the class treated
> differently ?
>
> Kindly explain
>
> Thanks
> V.Subramanian



 
Reply With Quote
 
James Kanze
Guest
Posts: n/a
 
      06-26-2007
On Jun 26, 4:49 am, "(E-Mail Removed), India"
<(E-Mail Removed)> wrote:
> Consider the program


> #include <iostream>


> using namespace std;


> class Test
> {
> public:
> Test(Test_int c_value)
> {
> value = c_value;
> }


> typedef int Test_int;


> private:
> Test_int value;
> };


> int main()
> {
> Test t(100);
>
> return 0;
> }


> Here I am getting compilation error for the line
> Test(Test_int c_value)
> because it uses Test_int type which is not known at that point and is
> declared afterwards.


Correct.

> If I declare
> typedef int Test_int;
> before the the ctor, the compilation error goes. But the data member
> 'value' is used inside the ctor at which point the definition of the
> variable is not known(it is defined later in the private section).


Correct.

> My doubt is why the compiler is unable to see the typedef declaration
> for Type_int when it occurs later in the class; but it is able to see
> the data member 'value' used in the ctor but which is actually defined
> inside the private section later in the class.


> Why are the typedef and variable definition inside the class treated
> differently ?


They aren't, but the function body is treated differently from
the declaration. Informally, everything within the {...} of the
function is parsed and compiled as if it followed the class
definition. The part of the declaration which precedes the
opening brace isn't, however. (In the case of a constructor,
the initializer list is also processes as if it followed the
complete class definition.)

--
James Kanze (GABI Software) email:(E-Mail Removed)
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34

 
Reply With Quote
 
James Kanze
Guest
Posts: n/a
 
      06-26-2007
On Jun 26, 8:08 am, John Harrison <(E-Mail Removed)> wrote:
> (E-Mail Removed), India wrote:
> > Consider the program


> > #include <iostream>


> > using namespace std;


> > class Test
> > {
> > public:
> > Test(Test_int c_value)
> > {
> > value = c_value;
> > }


> > typedef int Test_int;


> > private:
> > Test_int value;
> > };


> > int main()
> > {
> > Test t(100);


> > return 0;
> > }


> > Here I am getting compilation error for the line
> > Test(Test_int c_value)
> > because it uses Test_int type which is not known at that point and is
> > declared afterwards.


> > If I declare
> > typedef int Test_int;
> > before the the ctor, the compilation error goes. But the data member
> > 'value' is used inside the ctor at which point the definition of the
> > variable is not known(it is defined later in the private section).


> > My doubt is why the compiler is unable to see the typedef declaration
> > for Type_int when it occurs later in the class; but it is able to see
> > the data member 'value' used in the ctor but which is actually defined
> > inside the private section later in the class.


> > Why are the typedef and variable definition inside the class treated
> > differently ?


> My understanding is that this rule exists to make life easier for
> compiler writers. The C/C++ syntax is ambiguous (in the LALR(1) sense)
> unless you know which names are typedefs and which names are just
> ordinary identifiers. So special requirements are made of typedefs,
> namely that you must declare them before you use them.


The rule you're thinking of applies to templates, and requires
the use of typename in some cases. Here, the rule has nothing
to do with whether the symbol is a type. Within function
bodies, default arguments, exception-specifications, and
constructor ctor-initializers (including such things in nested
classes), the class is considered complete; it's as if these
things were parsed after the closing brace of the class
definition. So using Test_int or value within the function
definition is legal, but using it before the opening brace of
the function (except as a default argument or in an exception
specifier) isn't.

--
James Kanze (GABI Software) email:(E-Mail Removed)
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34

 
Reply With Quote
 
 
 
Reply

Thread Tools

Posting Rules
You may not post new threads
You may not post replies
You may not post attachments
You may not edit your posts

BB code is On
Smilies are On
[IMG] code is On
HTML code is Off
Trackbacks are On
Pingbacks are On
Refbacks are Off


Similar Threads
Thread Thread Starter Forum Replies Last Post
CRTP-problem: How can the base class typedef a derived class' typedef? oor C++ 0 05-20-2008 12:39 PM
variable declaration inside eval inside with Mehmet Yavuz S. Soyturk Javascript 3 04-12-2007 01:02 PM
Variable declaration taken as a function pointer declaration Bolin C++ 4 12-02-2005 05:28 PM
"virtual outside class declaration" and "declaration does not declare anything" kelvSYC C++ 6 05-17-2005 08:58 AM
Function declaration in class declaration Ovidesvideo C++ 4 12-10-2004 06:36 PM



Advertisments