I have not found a way to initialize the class member succesfully inside the constructor and I can not figure out why.
I have a header file:
#pragma once
struct STATE_MOUSE {
bool moving;
int left_button;
int right_button;
int middle_button;
bool scroll_up;
bool scroll_down;
};
class Message {
private:
static STATE_MOUSE state_mouse;
public:
Message();
~Message();
};
Then I have a source file:
#include "message.hpp"
STATE_MOUSE Message::state_mouse = {false, 0, 0, 0, false, false};
Message::Message() {
//Would like to initialize state_mouse here somehow.
}
Message::~Message() {
}
Now to the issue. This set up seems to work. However I am used to initialize members inside a constructor and I have not found a way to do that with this static struct member.
The following method does not work, could someone explain why?
state_mouse.moving = false;
When you declare a member as static it will belong to the class with only one instance and not to the objects of the class, therefore you cannot initialize it inside the constructor. The constructor is a special member function which mainly exists to initialize the non static members of a new object.
Note that a static member is shared by all objects of the class and when an object changes it, the change can be seen from all other objects of the same class. If this is what do you want to achieve, then the method you shown is good.
Static member variables are not associated with each object of the class. It is shared by all objects.
If you declare a static variable inside the class then you should define it in the cpp file, otherwise, you can get error undefined reference.
Note that if the static member variable is of const int type (e.g. int, bool, char), you can then declare and initialize the member variable directly inside the class declaration in the header file.
Related
I know how to access static member variable in static member method - these are two ways I usually use (very simplified):
class S{
private:
static const int testValue = 5;
public:
static int getTestValue0(){
return testValue;
}
static int getTestValue1(){
return S::testValue;
}
};
( working example on : http://ideone.com/VHCSbh )
My question is: is there any more explicit way how to access static member variable than ClassName::staticMemberVar?
Is there something like self:: in C++ ?
...simply I am looking for something like this for referencing static members.
Is there something like self:: in C++ ?
No there is no such feature, but you can use a class local typedef:
class MyClass {
typedef MyClass self;
static int testValue;
static int getTestValue1(){
return self::testValue;
}
};
See a working demo.
There is no support to use something other than class name. You'll need to implement it.
Static Function Members: By declaring a function member as static, you
make it independent of any particular object of the class. A static
member function can be called even if no objects of the class exist
and the static functions are accessed using only the class name and
the scope resolution operator ::.
to read details click here
i have like 5 erros when trying to compile the code below.
it's like:THey are mainly pointing on static string rzym and static int arab.
the main errors:
In arab2rzym function:
- : invalid use of member ‘RzymArab::arab’ in static member function
- : error: from this location
- : error: invalid use of member ‘RzymArab::arab’ in static member function
- : invalid use of member ‘RzymArab::rzym’ in static member function
- : cannot declare member function ‘static std::string RzymArab::arab2rzym(int)’ to have static linkage [-fpermissive]
Here is the code:
#include <iostream>
#include <string>
using namespace std;
class RzymArab
{
private:
string rzym[13] = {"I","IV","V","IX","X","XL","L","XC","C","CD","D","CM","M"};
int arab[13] = {1,4,5,9,10,40,50,90,100,400,500,900,1000};
public:
static int rzym2arab(string);
static string arab2rzym(int);
};
static string RzymArab::arab2rzym(int x)
{
int i=12;
string s="";
while(x>=1)
{
if(x>=arab[i])
{
x-=arab[i];
s=s+rzym[i];
}
else
i-=1;
}
return s;
}
int main()
{
string x;
x=RzymArab.arab2rzym(1164);
cout<<x<<endl;
return 0;
}
I would be grateful for helping!I tired some things but still bunch of errors. I want to use elements from class without creating an object.Any ideas?
You can't access non static class member variables from static member functions. You'll need to make them static also:
class RzymArab {
private:
static string rzym[13];
static int arab[13];
public:
static int rzym2arab(string);
static string arab2rzym(int);
};
Also those need to be defined separately (in your class' .cpp file usually):
string RzymArab::rzym[13] =
{"I","IV","V","IX","X","XL","L","XC","C","CD","D","CM","M"};
int RzymArab::arab[13] = {1,4,5,9,10,40,50,90,100,400,500,900,1000};
Additionally note you don't use the static keyword for the (non inline) definition of your static function (it's invalid syntax). Just write:
string RzymArab::arab2rzym(int x) {
// ...
}
See the fully fixed, compilable and running sample here please.
The deal with class (also known as "static") vs. instance member functions is that an instance member function can access both static and instance members (variables and functions), while static member functions can access only static members. That is why you need to make the
int arab[13]; // The initializer needs to go into cpp file
string rzym[13];
member static in the class:
static int arab[13];
static string rzym[13];
The initializer needs to go to the cpp file:
// This goes into the CPP file
int RzymArab::arab[13] = {1,4,5,9,10,40,50,90,100,400,500,900,1000};
string RzymArab::rzym[13] = {"I","IV","V","IX","X","XL","L","XC","C","CD","D","CM","M"};
Finally, you refer to static members with the scope resolution operator ::, not with a dot:
x=RzymArab::arab2rzym(1164);
I method that is declared static cannot access data members in the class.
Perhaps you should drop static everywhere?
You cannot access non-static members of a class from a static method of the same class without an object of that class. Non-static members exist only within the context of an object and cannot be access from static methods, that have class scope.
So you either:
make all members static
make all members non-static
pass an object to the static methods used to access the non-static members
Also notice that the static keyword is only necessary when declaring the function, not when you define it.
It isn't possible. A static method can only access other shared things (variables, other methods, etc.).
Example:
Say we have a Square class. You can create an object by passing the height and width into the constructor.
Square mySquare(2,2)
The Square class has a method for getting the area of the object. So you would call it as so:
double area = mySquare.getArea();
That works and all because you are using the instance variables for that specific object's height and width to calculate it. But lets say we want to calculate the area of a square before we create the object to make sure it's valid. So we would call the static getArea(double w, double h) method that is in the Square class.
double area = Square.getArea(2,4);
This works. But if you tried to call the getArea() method (that doesn't have parameters) would give you an error because it wouldn't know what height and width to use because they haven't been defined yet.
double area = Square.getArea(); //This will give you an error.
Hope this helps.
when I want to have a static pointer as a member of a class I need constexprfor the initialisation with nullptr.
class Application {
private:
constexpr static Application* app = nullptr;
}
Can someone explain me why I need to do that? I cannot find the exact reason why it`s necessary that the static variable has to exist at compile time.
That's because you're initialising it inside the class definition. That's only allowed for constant integral and enumeration types (always) and for constexpr data members (since C++11). Normally, you'd initialise it where you define it (outside the class), like this:
Application.h
class Application {
private:
static Application* app;
}
Application.cpp
Application* Application::app = nullptr;
Note that you need to provide the out-of-class definition even in the constexpr case, but it must not contain an initialiser then. Still, I believe the second case is what you actually want.
If you don't want it to be constexpr (and it's not an integer) then you need to initialise it outside of the class body:
class Application
{
private:
static Application* app;
};
Application* Application::app = nullptr;
Typically, you need to initialise a static member variable outside the class declaration, unless it is const. I think this explains it better than I could.
Static variables do not need to "exist at compile time". But if you want to initialize a static variable inside the class, its value needs to be known at compile time.
However, I do not know the reason for this restriction.
There is a static member in a struct, because it is needed in the destructor.
struct Form
{
// ...
~Form()
{
// access World here
}
static btDynamicsWorld *World;
};
Is there a way to initialize this static member from within another function?
void ModulePhysics::Init()
{
// ...
btDynamicsWorld *Form::World = /* ... */;
}
My current code results in those two compiler errors.
Error 1 error C2655: 'Form::World' : definition or redeclaration illegal in current scope
Error 2 error C2086: 'btDynamicsWorld *Form::World' : redefinition
No, you can't. But you can initialize it to NULL, and in the function, if it is NULL, do the real initialization.
Edit: Provide an example:
void ModulePhysics::Init()
{
// ...
if(Form::World == NULL)
{
// The real initialization
}
}
Somewhere, on file scope (in the C file, not in the header!):
btDynamicsWorld* Form::World = NULL;
No you can't.
The declaration of a static data member in the member list of a class is not a definition. You must define the static member outside of the class declaration, in namespace scope.
Here you can get a more detailed description of how and where you can initialize static class variables.
in the init() method remove the type in front of the static variable.
it should solve your issue, I hope.
1) All static class members (except integral members initialized immediately in the class definition) should also be defined outside (preferrably in a .cpp file, so that the definition is processed only once by compiler). For example:
// form.h
struct Form
{
static btDynamicsWorld *World;
};
// form.cpp
// You can initialize World here as well if you want to,
// but you don't have to, as long as it's not const.
// However, it is generally a good idea to initialize
// pointers to NULL (or nullptr in C++11).
btDynamicsWorld *Form::World;
This can only be done at global scope. If you don't do this, you will get linker errors (undefined symbol) if you try referencing this variable.
2) What you are seemingly trying to do is not "initialize", but just assign to the static member. You are doing it almost correctly, but you don't need to redeclare the type:
void ModulePhysics::Init()
{
Form::World = /* ... */;
}
3) I don't really see why do you need to make anything static to access it from the destructor. Destructor is responsible for deleting instance variables, but they are not yet deleted when the destructor's body is executing. So you may just as well use a "normal" class member, unless you are planning to share its value across different class instances.
I have noticed that some of my functions in a class are actually not accessing the object, so I made them static. Then the compiler told me that all variables they access must also be static – well, quite understandable so far. I have a bunch of string variables such as
string RE_ANY = "([^\\n]*)";
string RE_ANY_RELUCTANT = "([^\\n]*?)";
and so on in the class. I have then made them all static const because they never change. However, my program only compiles if I move them out of the class: Otherwise, MSVC++2010 complains "Only static constant integral variables may be initialized within a class".
Well that's unfortunate. Is there a workaround? I would like to leave them inside the class they belong to.
They can't be initialised inside the class, but they can be initialised outside the class, in a source file:
// inside the class
class Thing {
static string RE_ANY;
static string RE_ANY_RELUCTANT;
};
// in the source file
string Thing::RE_ANY = "([^\\n]*)";
string Thing::RE_ANY_RELUCTANT = "([^\\n]*?)";
Update
I've just noticed the first line of your question - you don't want to make those functions static, you want to make them const. Making them static means that they are no longer associated with an object (so they can't access any non-static members), and making the data static means it will be shared with all objects of this type. This may well not be what you want. Making them const simply means that they can't modify any members, but can still access them.
Mike Seymour has given you the right answer, but to add...
C++ lets you declare and define in your class body only static const integral types, as the compiler tells. So you can actually do:
class Foo
{
static const int someInt = 1;
static const short someShort = 2;
// etc.
};
And you can't do that with any other type, in that cases you should define them in your .cpp file.
Some answers including even the accepted answer seem to be a little misleading.
You don't have to
Always assign a value to static objects when initializing because that's optional.
Create another .cpp file for initializing since it can be done in the same header file.
You can even initialize a static object in the same class scope just like a normal variable using the inline keyword.
Initialize with no values in the same file
#include <string>
class A
{
static std::string str;
static int x;
};
std::string A::str;
int A::x;
Initialize with values in the same file
#include <string>
class A
{
static std::string str;
static int x;
};
std::string A::str = "SO!";
int A::x = 900;
Initialize in the same class scope using the inline keyword
#include <string>
class A
{
static inline std::string str = "SO!";
static inline int x = 900;
};
Since C++11 it can be done inside a class with constexpr.
class stat {
public:
// init inside class
static constexpr double inlineStaticVar = 22;
};
The variable can now be accessed with:
stat::inlineStaticVar
Static member variables must be declared in the class and then defined outside of it!
There's no workaround, just put their actual definition in a source file.
From your description it smells like you're not using static variables the right way. If they never change you should use constant variable instead, but your description is too generic to say something more.
Static member variables always hold the same value for any instance of your class: if you change a static variable of one object, it will change also for all the other objects (and in fact you can also access them without an instance of the class - ie: an object).
I feel it is worth adding that a static variable is not the same as a constant variable.
using a constant variable in a class
struct Foo{
const int a;
Foo(int b) : a(b){}
}
and we would declare it like like so
fooA = new Foo(5);
fooB = new Foo(10);
// fooA.a = 5;
// fooB.a = 10;
For a static variable
struct Bar{
static int a;
Foo(int b){
a = b;
}
}
Bar::a = 0; // set value for a
which is used like so
barA = new Bar(5);
barB = new Bar(10);
// barA.a = 10;
// barB.a = 10;
// Bar::a = 10;
You see what happens here. The constant variable, which is instanced along with each instance of Foo, as Foo is instanced has a separate value for each instance of Foo, and it can't be changed by Foo at all.
Where as with Bar, their is only one value for Bar::a no matter how many instances of Bar are made. They all share this value, you can also access it with their being any instances of Bar. The static variable also abides rules for public/private, so you could make it that only instances of Bar can read the value of Bar::a;
Just to add on top of the other answers. In order to initialize a complex static member, you can do it as follows:
Declare your static member as usual.
// myClass.h
class myClass
{
static complexClass s_complex;
//...
};
Make a small function to initialize your class if it's not trivial to do so. This will be called just the one time the static member is initialized. (Note that the copy constructor of complexClass will be used, so it should be well defined).
//class.cpp
#include myClass.h
complexClass initFunction()
{
complexClass c;
c.add(...);
c.compute(...);
c.sort(...);
// Etc.
return c;
}
complexClass myClass::s_complex = initFunction();
If your goal is to initialize the static variable in your header file (instead of a *.cpp file, which you may want if you are sticking to a "header only" idiom), then you can work around the initialization problem by using a template. Templated static variables can be initialized in a header, without causing multiple symbols to be defined.
See here for an example:
Static member initialization in a class template
Optionally, move all your constants to .cpp file without declaration in .h file. Use anonymous namespace to make them invisible beyond the cpp module.
// MyClass.cpp
#include "MyClass.h"
// anonymous namespace
namespace
{
string RE_ANY = "([^\\n]*)";
string RE_ANY_RELUCTANT = "([^\\n]*?)";
}
// member function (static or not)
bool MyClass::foo()
{
// logic that uses constants
return RE_ANY_RELUCTANT.size() > 0;
}