i have written a code like this in C++ on linux version 6.2

class sample
{
static int a;
public:
static void accept()
{
cout<<"Enter a value for a"<<endl;
cin>>a;
}
static void disp()
{
cout<<a<<endl;
}
};
void main()
{
sample::accept();
sample::disp();
}
is this code valid?static functions are created before any objects are created right?so they can be refered by the class name and they can be called by scope resolution operator.
but this code is giving me an error.can anyone solve this problem.or may be there is some error in program?

bye
abida

add this after the declaration of the class:

int sample::a = 0;

hi champ
u didn't explain y this kind of initialisation has to be given?
i think on unix platform the same program works even without this kind of initialisation,then y not on linux?

The declaration of a does not define an integer; no storage space is set aside.
Unlike the non-static member variables, no storage space is set aside by instantiating a sample object, because the a member variable is not in the object. Thus, variable a has to be defined and initialized.

1. The C++ is platform independent. The language as such
doesn't care if it's Unix or Mac.
2. int sample::a = 0; is important from Linker's perspective.
What that means is : variable a is static and belongs to class
sample which in turn means, the variable a exists even if you
do not create any object of 'sample'. In short, it's a global
variable, but with a little more security. Since it's a global var,
it needs to be defined (not just declared).
3. BTW, in your code, 'disp' need not be a 'static' method. IT can
as well be a regular one.

hey thanx a lot for ur replies ,now i got the solution for my problem,thanx one and all
bye
abida

why is that so, i thought static membe variables can be accessed only by static member functions. am i wrong?

It's the other way around.

A static member has a lifetime of the entire run-time of the program.

A non-static (auto, register or volatile) member has the same lifetime as the object to which it belongs (from the start of the constructor body after object allocation to the end of the destructor body before object clean-up). If you have multiple objects of the same class, each object gets its own member variable, seperate and independant of the others.

A static method also has a “lifetime” of the entire run-time of the program; it's just a normal method that happens to be in the scope of a class, and subject to class protection rules.

A non-static method is implicitly passed a reference to the object by a hidden parameter (called this). So you need to have a defined object in order for the method to be called; if no object is defined, then the method can't be called. (So, while you could make disp non-static, you would need to allocate an object of type sample in order to call it).

Any method can access a static member variable, assuming that it's got sufficient permissions to do so (i.e. is in the same class; all member variables should always be declared private).

A non-static member variable can only be accessed from the object to which it belongs. Since a static member does not belong to an object, it can't access non-static variables.


Btw, the current version of Linux is 2.6.something (last time I checked), so I suspect that 6.2 is the version of your distribution. Which doesn't tell us anything because you've not said which distribution you're using.

Hope that helps,

— Robert J. Lee