I've been searching a lot for an answer and can´t find it anywere. Say i have:
class foobar{
public:
char foo() const;
};
, in my foobar.h
When I want to implement this class in foobar.cpp should I repeat const?:
char foobar::foo() const{
//...my code
}
Or can i do (whitout the const)
char foobar::foo() {
//...my code
}
If this is a duplicate I'm sorry, but no other question truly answered this.
Yes, you have to include the const qualifier in the definition.
If you write:
class Foo
{
public:
int f () const;
};
And in implementation file if you write:
int Foo::f () { /*...*/ }
then the compiler will emit an error saying that there is not function with signature int f () in the class.
If you put the const keyword in your implementation file too, it will work.
It is possible to overload functions according to the object constness.
Example:
class Foo
{
public:
int foo () { std::cout << "non-const foo!" << std::endl; }
int foo () const { std::cout << "const foo!" << std::endl; }
};
int main ()
{
Foo f;
const Foo cf;
f.foo ();
cf.foo ();
}
The output will be (as expected):
non-const foo!
const foo!
As we did with const, you can overload a function based on the object volatileness too.
You absolutely must include the const qualifier in the implementation.
It is possible to overload functions according to their constness. In fact this is an important part of the language.
Yes, because const is part of the signature. You can define two member functions that differ only in const-ness.
The easiest way to see that it is required is to test your code with your favorite compiler - the code below will not compile:
struct foobar{
char foo() const;
};
char foobar::foo() {
return 'a';
}
int main() {
foobar().foo();
return 0;
}
You should get an error similar to this:
error: prototype for
'char foobar::foo()'does not match any in class'foobar'char foobar::foo()
If your variable is char foo() const; and you want to implement it you have to name it as same as you declared it.
char foobar::foo() const{
//...my code
}
char foobar::foo(); is different to char foobar::foo() const;. It means you can have them both in your class declaration like :
class foobar{
public:
char foo() const;
char foo();
};
Yes, must need const qualifier in foobar.cpp file. when you use const in the method signature, you are telling the compiler that memory pointed to by this can't be changed by this method (which is foobar here).
