This question already has answers here:
Undefined reference to static class member
(9 answers)
Closed 2 years ago.
I have declared a static variable in a file say "example.hxx" and am calling this variable in the cxx file "example.cxx" in this way
example.hxx file :-
class example{
private:
static int p;
public:
void func();
};
CXX file
#include <example.hxx>
class example{
void func(){
std::cout<<p;
}
}
I get an error of undefined reference to p.
Why does this happen and how to solve this ?
I have seen some answers in relation to this question but none deals with separate hxx and cxx files, instead they answer wrt main function. Would be great if someone clears my doubt !
You have only declared p. You need to define it as well, like this, outside the class:
// .hpp file
class example{
private:
static int p; // declaration
};
// .cpp file
int example::p = 42; // definition
Alternatively, you could do:
class example{
private:
inline static int p = 42; // inline definition
};
Your syntax is incorrect. First, missing ; when defining example in the .hxx file. Second, you have multiple definitions of the class example. Instead, you should define func as follows:
void example::func(){
....
}
Third, you have multiple definitions of func. Replace void func(){}; with void func();.
After that's done, you're also missing a definition of p. Use
class example{
private:
static inline int p = some_value;
...
Or add a definition in the .cxx file.
Related
This question already has answers here:
Undefined reference to static class member
(9 answers)
How to initialize private static members in C++?
(18 answers)
Closed 6 years ago.
I have a file A.hpp as such:
class A
{
private:
static std::string s;
public:
void modify_string();
};
I am implementing this in a file A.cpp as such:
#include "A.hpp"
void A::modify_string()
{
s = "something"; // Error here.
}
My main class:
int main()
{
A a;
a.modify_string();
}
I understand static variables are shared by all the class instances. I also went through this SO post where it says how to access the static member. Public static member of class . Could you please let me know where my concept is missing at?
Edit:
I am getting this error:
error: undefined reference to A::s
When you define:
void modify_string() {
s = "something"; // Error here.
}
You are creating a new function, not defining the member function modify_string of the class A. You need to do:
void A::modify_string() {
To inform the compiler that you are defining the member function modify_string for class A.
You also need a ; after your class definition.
Finally, the variable s is static so it needs to be defined seperatly somewhere so the linker can find a reference to it. So add:
std::string A::s = "default";
This was clearly described in the link you provided for your question.
Here is a working example: http://ideone.com/iQ6Kux
You need to reserve storage for s in exactly one compilation unit.
Do that by writing
std::string A::s;
In exactly one source file.
Your definition void modify_string() {...} in A.cpp is not defining the member function of the class, it's defining a separate global function with the same name. You probably meant
void A::modify_string()
{
s = "something";
}
This question already has answers here:
Undefined reference to static variable [duplicate]
(2 answers)
Closed 9 years ago.
I am beginner to C++ and have a doubt about static member variables and member functions.
I have implemented a class as follows -
class Foo
{
private:
static int myVariable;
public:
static void setMyVariable()
{
myVariable = 100;
}
static void resetMyVariable()
{
myVariable = 0;
}
};
There are following considerations when I wrote a code like that -
I want only one instance of class Foo. Thats why I made all member variables and functions as static.
I don't want the outside code to touch myVariable
I have put this class in a header file and included in my main file. When I do this, I get an error undefined reference to Foo::myVariable
I want to know if I can write a code which can satisfy above requirements?
Thanks !
You need to define static class variables somewhere:
e.g. in your main C++ file,
int Foo::myVariable;
Note that technically, by making everything static, you may have no instances of Foo.
This question already has answers here:
How to initialize private static members in C++?
(18 answers)
Closed 9 years ago.
So I have the following c++ class
class MyClass:
public:
static void InitObject();
private:
static MyObject *myObject;
};
And then in the .cpp file I do
void MyClass::InitObject
{
myObject = new MyObject();
}
However, I get a compiler error saying that "myObject" was referenced from InitObject() and then it says Linker command failed with exit code 1.
Why doesn't this work? How do I fix it?
Since static data members of classes in C++ need memory space that is separate from the instance memory, they need to be defined, in addition to being declared in the class.
You do that in a separate translation unit (in your CPP file) like this:
MyObject *MyClass::myObject;
This definition tells the compiler to allocate space for myObject in the static memory area. Without this definition, the code is going to compile, but the linker will report an error, because it is responsible for ensuring that all referenced static objects have memory allocated to them.
Extend your .cpp file with the following definition for myObject:
MyObject* MyObject::myObject = NULL;
NOTE:
For your particular case you might be better off saying:
class MyClass:
{
public:
static MyClass& instance();
private:
MyClass() {}
};
and in .cpp file:
MyClass& MyClass::instance()
{
static MyClass myInstance;
return myInstance;
}
I'd prefer this over using new MyClass(). Any access to the instance() method will guarantee your instance is initialized exactly once, and you'll get a valid reference to it.
'Space' is completely allocated on the stack then, as well for the reference as for the instance itself.
You never allocated space for MyObject::myObject. Put this in the CPP file:
MyObject* MyObject::myObject;
This question already has answers here:
What does it mean to have an undefined reference to a static member?
(2 answers)
Closed 9 years ago.
I have a .cpp file that looks something like this:
//other code
namespace {
class C1;
class C2;
class C2{
public: static int counter;
//member functions here
};
class C1{
//other code
C2::counter = 10;
};
}
When I run 'make' I get the following error:
relocation R_386_GOTOFF against undefined symbol '(anonymous namespace)::C2::counter' can not be used when making a shared object...
Am I missing something simple here? Shouldn't the static int be available for class C1 to change it? Also, I am developing this as a part of the Clang library's. Also, I can share the Makefile if that helps.
You have missed out on providing the definition of you static variable. This definition must occur outside the class and only one definition is allowed. Usual way to do this is to provide the definition in the implementation file.
Because you are directly using it, without providing any definition for it, you are getting the error.
This question already has answers here:
Declaring static data members of normal class and class template
(2 answers)
Closed 9 years ago.
// A.h
class A {
public:
static int a;
};
int A::a = 0;
If I try to include A.h in multiple .cpp files, link would fail with multiple definition of A::a. I think this makes sense because each .obj file contains A::a
However, I could use a template,
// A.h
template<class T>
class A {
public:
static T a;
};
template<class T>
T A<T>::a = 0;
I can now include A.h in multiple .cpp files and also I can assign the value A<int>::a = 100; in one .cpp file and get the same value in another one with A<int>::a.
When does template make such difference?
Is there only 1 copy of this static variable? Which .obj will keep this variable?
Is the constructor called only once? If the initial value is different, which one wins?
When does template make such difference?
Always. I suppose I don't understand the question.
Is there only 1 copy of this static variable?
Only one copy in the final program for each distinct type T the template was instantiated with.
Which .obj will keep this variable?
All of them that were generated from translation units where the template was instantiated. The linker then chooses one and discards all others.
Is the constructor called only once?
Once for each specialization.
If the initial value is different, which one wins?
That would be a violation of the One Definition Rule. Such a program would be ill-formed, no diagnostic required.
Why not define static member in the souce file that implements the class A? Then you should be able to include A.h in multiple source files w/o problem.
// A.h
class A {
public:
static int a;
};
// A.cpp
int A::a = 0;