Difference between undefined methods and pure virtual methods in a header file - c++

Question

What are the advantages or disadvantages of using a class declaration with pure virtual methods over using one with undefined members? Example:
Pure virtual functions
TestClass.h
namespace test {
class TestClass {
virtual void DoSomething() = 0;
}
}
TestClass.cpp
namespace test {
class TestClassImpl : public TestClass {
void DoSomething() {
std::cout << "Hello!" << std::endl;
}
}
}
Undefined methods
TestClass.h
namespace test {
class TestClass {
void DoSomething();
}
}
TestClass.cpp
namespace test {
void TestClass::DoSomething() {
std::cout << "Hello!" << std::endl;
}
}
I know that virtual function calls in C++ have an overhead due to indirection and extra branching, but for now these overheads don't concern me. I'm more interested in having extensible, correct code (FYI: I am a C++ newb, but not a programming newb).

Answer 1

They have completely different uses, therefore you should not treat them the same or try to compare them.
A pure virtual method means that a derived class must implement that method itself for it to be complete. This will usually be used like this:
Object.hpp
class Object{
public:
virtual void use() = 0;
};
class Banana: public Object{
public:
void use(){std::cout << "You ate the Banana! Good work." << std::endl;}
};
class Rock: public Object{
public:
void use(){std::cout << "You use the Rock. Nothing happens." << std::endl;}
};
So that later on you can refer to instances of Rock or Banana as Objects and know that they will have a use function.
E.g.
main.cpp
#include "Object.hpp"
int main(){
std::vector<Object*> objects;
Banana banana;
Rock rock;
objects.push_back(&banana);
objects.push_back(&rock);
for(const Object *o : objects)
o->use();
}
If you decide not to use virtual functions, then you can't treat the objects as Objects, per se.
E.g.
main.cpp
class Banana{
public:
void use();
};
class Rock{
public:
void use();
};
int main(){
std::vector<???> objects;
Banana banana;
Rock rock;
objects.push_back(&banana); // can't do
objects.push_back(&rock); // or this
for(const ??? *o : objects)
o->use(); // and definitely not this
}
If you try to do this by just delegating your implementations of functions into a different code unit, well, I don't know what you will be trying to do.
You could actually implement your virtual functions in another file, just so long as you do implement them; otherwise when trying to access that kind of object as an Object you will get errors.
You would want to use functions with outside implementations when dealing with things like libraries and very large projects. You do this so that for every translation of the code you don't have to compile that function again, just call to the already implemented code :D
This makes build times hella shorter.