Foo.cpp

Foo::Foo()
: _impl(Foo::createImplementation())
{
}

void Foo::platform_independent() {
  // do some stuff that is the same on all platforms
}

void Foo::platform_specific() {
  _impl->do_platform_specific();
}

Foo.h

class Foo {

public:
  Foo();
  ~Foo() {}
  
  void platform_independent();
  void platform_specific();
  
private:
  FooImpl* _impl;
  
public:
  static FooImpl* createImplementation();
};

Foo_Mac.cpp

/*** Compile only in Mac project ***/

#include "FooImplMac.h"

FooImpl* Foo::createImplementation() {
  return new FooImplMac();
}

Foo_Win.cpp

/*** Compile only in Windows project ***/

#include "FooImplWin.h"

FooImpl* Foo::createImplementation() {
  return new FooImplWin();
}

FooImplInterface.h

/*** Foo implementation abstract interface ***/

class FooImplInterface {
public:
  FooImplInterface() {}
  virtual ~FooImplInterface() {}
  
  virtual void do_platform_specific() = 0;
}

FooImplWin.cpp

#include "FooImplWin.h"

FooImplWin::FooImplWin()
: FooImplInterface()
{
}

FooImplWin::do_platform_specific() {
  // Do some stuff the Windows way
}

FooImplWin.h

#include "FooImpl.h"

class FooImplWin : public FooImpl {
public:
  FooImplWin();
  virtual ~FooImplWin() {}
  
  virtual void do_platform_specific();
}