C / C++ / MFC

Shy Agam wrote:

However, this somehow causes a problem if classes from the same .h file should be used by different .cpp files.
The first .cpp file including the .h file gets compiled, but the others throw an "undefined reference" compile error.
It's as if I never included the .h file on the other files.

// myclasses.h
#ifndef _MYCLASSES_H_
#define _MYCLASSES_H_

// class definitions here...

#endif // _MYCLASSES_H_

// mysource1.cpp
//...
#include "myclasses.h"

// use the classes here

// mysource2.cpp
//...
#include "myclasses.h"

// use the classes here

Shy Agam wrote:

It seems that this is some kind of linkage problem of some sort, but I can't figure it out.

#include <HeaderFileFromLibrary.h>

using namespace NamespaceFromHeaderFile;

int main(int argc, char **args)
{
    ClassFromHeaderFile *pClass = ClassFromHeaderFile::GetInstance();
    
    .
    .
    .

    return 0;
}

Cedric Moonen wrote:

Are you sure you linked correctly to the library ?

Shy Agam wrote:

As far as I can tell I did link the library correctly.

paul_71 wrote:

No, what he's getting is an linker error.

paul_71 wrote:

these hierarchical"replies" suck!

Richard MacCutchan wrote:

Is GetInstance() a static member with public visibility?

Aescleal wrote:

PS: It's also identical to the behaviour of global variables - declare in a header, define in source. Which is a big hint why statics are bad, bad, bad...

// A.h

class A
{
    private:
        static B b;
};

// A.cpp

A::B b( b_init );

// A.cpp

namespace
{
    B b;
}

Aescleal wrote:

So where would you use a class static instead of just declaring a variable in an anonymous namespace?

Aescleal wrote:

They've got exactly the same visibility, thread safety issues and initialisation order problems

Tim Craig wrote:

I suppose the classic example is where you want to keep stats on the class such has how many instances are currently running rampant.

template<class T> 
class InstanceCountable { :) 
 static int sCounter;
protected:
 InstanceCountable() {
  InstanceCountable<T>::sCounter++;
 }
 ~InstanceCountable() {
  InstanceCountable<T>::sCounter--;
 }
public:
 static GetCount() {
  return InstanceCountable<T>::sCounter;
 }
};

template<class T>
int InstanceCountable<T>::sCounter(0);

// ...and then

class A : public InstanceCountable<A> {
 //...
};

class B : public InstanceCountable<B> {
 //...
};

// etc...

int main() {
 A a1, a2;
 std::array<B, 10> barr;

 std::cout << 
  A::GetCount() << std::endl // prints 2
  B::GetCount() << std::endl;// prints 10
}