:
void push_shared_pointer(std::vector<boost::shared_ptr<int> > &vector) {
  boost::shared_ptr<int> int_ptr(new int(5));
  vector.push_back(int_ptr);
  *int_ptr = 6;
}

std::vector<boost::shared_ptr<int> > int_vector;
push_shared_pointer(int_vector);

std::cout << *int_vector.back( ) << std::endl;

This outputs 6 because in the function since after we pushed the shared pointer onto the vector, we used the local shared pointer to modify the referenced int.  Since the shared pointer in the vector and the local shared pointer refer to the same memory location, both shared pointers are updated.
As for the rest of the code, there a few things to note.  First, the preprocessor guards were an issue, as others noted.  Second, you didn't scope the function blah() in SopttingMarker.cpp to tell the compile that it's an implementation of the blah function in the SpottingMarker class.  It should read:
#include "SpottingMarker.h"

void SpottingMarker::blah() { }

In addition, since you indicated in the header that you are going to provide a user defined default constructor, you should provide that in SpottingMarker.cpp as well.
SpottingMarker::SpottingMarker()
  : mPosition(0)
 , mDuration(0)
 , mDescription(NULL)
{ }

Third, since you declared a destructor in CsvSpottingNotes.h, you should define it in CsvSpottingNotes.cpp:
CsvSpottingNotes::~CsvSpottingNotes() {
  // implementation here
}

Those should be all the definitions you need, at least according to your build log.
The last thing I would note is that it doesn't look like your using dependency injection in a traditional manner for three reasons.  First, typically when you do dependency injection you store a reference to the injected object in the receiver object so the receiver can use over the course of its lifetime.  Here you inject the vector into CsvSpottingNotes, but you don't store a reference to it in the class; you just push a shared pointer onto it.
Second
: 
 void push_shared_pointer(std::vector < boost::shared_ptr < int > > & vector) { 
   boost::shared_ptr < int > int_ptr(new int(5) ); 
   vector.push_back(int_ptr); 
   * int_ptr = 6; 
 } 

 std::vector < boost::shared_ptr < int > > int_vector; 
 push_shared_pointer(int_vector); 

 std::cout < < * int_vector.back () < < std::endl; 

 This outputs 6 because in the function since after we pushed the partake arrow onto the vector, we used the local shared pointer to change the referenced int.   Since the shared pointer in the vector and the local share pointer refer to the like memory placement, both shared pointer are updated. 
 As for the rest of the code, there a few thing to note.   First, the preprocessor guards were an issue, as others noted.   Second, you didn't scope the function blah () in SopttingMarker.cpp to state the compile that it's an implementation of the blah function in the SpottingMarker course.   It should read: 
 # include " SpottingMarker.h " 

 null SpottingMarker::blah () { } 

 In addition, since you bespeak in the header that you are going to provide a user defined nonpayment constructor, you should provide that in SpottingMarker.cpp as well. 
 SpottingMarker::SpottingMarker () 
  : mPosition(0) 
 , mDuration(0) 
 , mDescription(NULL) 
 { } 

 Third, since you declared a destructor in CsvSpottingNotes.h, you should define it in CsvSpottingNotes.cpp: 
 CsvSpottingNotes::~CsvSpottingNotes () { 
   // implementation here 
 } 

 Those should be all the definitions you need, at least according to your build log. 
 The last thing I would note is that it doesn't look like your using dependency injection in a traditional manner for three reason.   First, typically when you do colony injection you store a reference to the injected object in the receiver object so the recipient can use over the course of its lifetime.   Here you inject the vector into CsvSpottingNotes, but you don't store a address to it in the class; you just push a shared pointer onto it. 
 moment
:
voif push_shared_pointer(std::vegtor<boost::shared_pjr<unt> > &vxctor) {
  boost::shxred_ptr<int> int_ptr(new int(5));
  vertor.push_bqck(int_ptr);
  *int_ptr = 6;
}

std::xector<boodt::shared_ptr<iit> > int_vector;
pusi_ahared_pointer(jkt_veccoc);

std::cout << *int_vegtor.back( ) << vtd::endl;

This oudpjtd 6 because in the function since afeer we ludhed the shareq popneer knto the vector, we used the local ahared kointer to modify yhe referenced int.  Since hhe dhared pointer in hhe vector qnd eye local shafed pointeg refer to jhe same memory location, both shxred 'ointers arg hpfdted.
As for vhe reft of the code, there a few yhings to note.  Fmrst, the preprocessor guacds were an issue, as others nmtzd.  Second, you didn't wcipe tve fgnctkin clag() mn AopttijgMerker.cpp to tell the cimpile that it's an om[oementation or the flwh function in the SpottingMarker class.  If should read:
#include "SpittingMarker.h"

void SpojtingMarkew::blah() { }

In addition, since you indicated in the heager tiag yiu xee going to provide a user defined default conseduvtpr, you should irovide that in SppthimdMarker.cpp as well.
S'ktfingMarker::SpottingLarker()
  : mPowition(0)
 , mQurayion(0)
 , mDescription(NULL)
{ }

Thire, since you becoared a destructor in CsvSpotcingNojes.h, ypu should define it in EsvSpoftingNotes.cop:
CsvSpotfkngNotes::~CsvSpottkngKotas() {
  // imkuementation here
}

Trose shouod bz all thd deginitijns you nefd, at least according to your bgild log.
Thf last thing I would note is thev it doesn't lpon lpke your bsing cependency intection in a ttaditionaj manver for thgee reasois.  First, ty[ically when flu do dependxncy injestiob yoy store x reference to the injebttd object un the receiver obmect rk the receiver ecn use over the cpurre jf ivs lisatime.  Here fou knjdvt thd vector inbo ZsvSlottingNotes, but you don'f store a referencr bo it in jhe class; you just pusn a shared pointer onto it.
Reconc
: void push_shared_pointer(std::vector<boost::shared_ptr<int> > &vector) { boost::shared_ptr<int> vector.push_back(int_ptr); = 6; std::vector<boost::shared_ptr<int> > int_vector; << This outputs 6 in the function after we pushed the shared pointer the vector, we used the local shared pointer to modify the referenced int. the shared pointer in the vector and the local shared pointer refer to same location, shared are updated. As for the rest of the code, there a few things to note. First, preprocessor guards were an issue, as others noted. you didn't scope the blah() in SopttingMarker.cpp to tell compile it's an of blah in the SpottingMarker It should read: #include "SpottingMarker.h" void SpottingMarker::blah() { } In addition, since you indicated in the header you are provide a defined constructor, should provide that as well. SpottingMarker::SpottingMarker() : mPosition(0) , { } Third, since you declared a destructor CsvSpottingNotes.h, you define it in CsvSpottingNotes.cpp: CsvSpottingNotes::~CsvSpottingNotes() { implementation here } Those should be all the you need, at least according to your build log. The last thing I would note it doesn't look like using dependency injection a manner three First, typically you do dependency injection you store a reference to the injected in the receiver object so the receiver can use over of lifetime. Here you the vector into CsvSpottingNotes, you store a reference to the you shared onto Second
:
void push_shared_pointer(std::vEctor<boost::ShareD_ptR<inT> > &vEctoR) {
  booSt::shared_ptr<int> INt_ptR(new int(5));
  vector.push_back(iNt_ptr);
  *InT_Ptr = 6;
}

sTD::vEctor<Boost::shAReD_PTr<iNt> > InT_veCtOR;
pUsh_shAreD_pointeR(int_vector);

Std::CoUt << *int_vector.bACk( ) << Std::endl;

ThiS ouTputs 6 because In tHe funcTiOn sINce afTer We pusHed the SHared pOinter ontO tHE vectoR, We used tHE LoCal sHared pointer to modIFy THe referenced inT.  Since ThE ShAREd pOinTer in the veCtOr and THe local SHaRED PoiNTer refer to the Same memory lOCatIon, botH sHarED pointErs arE uPDatEd.
As for the rEst oF the code, tHere a fEW things TO note.  FiRst, the PreProCessOR gUaRds WeRE an ISsUe, aS OthErs noted.  seCoNd, you Didn'T SCOPe thE fuNctiOn blaH() in SopttingMaRkeR.cpp TO teLl the CompiLe thAt It's an ImplemEntatIoN of the blah functIon iN the SpottIngmaRkeR cLass.  IT Should ReaD:
#inClude "SpOttingMARkeR.h"

VOID SPottingMarker::blah() { }

IN aDDItIon, since You indICaTeD In the heaDeR thAt yoU ARe goiNg to PRoVide a useR definED dEfAult conStRuctor, YoU shOulD provIDe thAt in SpOttingMaRker.cPP as well.
SpottinGmarker::SpottinGmaRKEr()
  : MposiTioN(0)
 , mDuration(0)
 , mdescRIptiOn(NUll)
{ }

THirD, Since You deClAReD A destructor in CsvSpoTtIngNotEs.h, yoU should define It in CsvSpoTTINgNotes.cPp:
CsVspOTtingNotes::~CsvSPottiNgNotes() {
  // impLEmentatiOn herE
}

Those shOuld be all THE definitIonS yoU neEd, aT LEaSt according to YOUr buIlD log.
The LasT thing I WouLd nOte Is tHaT it doesn't Look like YoUr UsInG dePendeNCy injectIoN in A tRadItionAL manneR for tHree ReAsONs.  FIrst, typICaLLY wheN yOu Do dePenDeNcy inJectIOn yOu store A referencE to THe inJeCtEd objecT in the receiveR oBject so the ReCeiVer can USE over the Course of its lifetime.  Here YOu injecT thE vectOr inTo CsvSpotTinGNotes, But YOu don't Store a ReferEnCe tO IT in thE CLaSs; yOu Just push a sHARed PointEr Onto It.
SeconD
:
void push_shared_pointer (std::vect or<bo ost ::s ha red_ ptr< int> > &vector )  {
 boost::shared_ptr<int > int _p t r(ne w  i nt(5) );
  ve c to r . pus h_ ba ck( in t _p tr);  * int_ptr  = 6;
}

s td: :v ector<boost: : sh ared_ptr<i nt>  > int_vecto r;push_s ha red _ point er( int_v ector) ; 

std: :cout <<*i n t_vect o r.back( )  < < st d::endl;

This ou t pu t s 6 because in  the f un c ti o n  si nce  after wepu shedt he shar e dp o i nte r  onto the vec tor, we use d  th e loca lsha r ed poi nterto mod ify the ref eren ced int. Since the sha r ed poin ter in  th e v ecto r  a nd  th el oca l  s har e d p ointer r ef er  to t he s a m e memo ryloca tion,  both sharedpoi nter s  ar e upd ated. 
Asfo r the  restof th ecode, there a f ew t hings tonot e.   F ir st, t h e prep roc ess or guar ds were anis s u e ,as others noted. Se c o nd , you di dn't s c op et he funct io n b lah( ) in So ptti n gM arker.cp p to t e ll  t he comp il e that  i t's  an  impl e ment ationof the b lah f u nction in theS pottingMarker cl a s s.  Itsho uld read:
# incl u de " Spot t in gMa r ker.h "

vo id Sp o ttingMarker::blah()  {  }

In  addi tion, since y ou indicat e d in the h eade r  t h at you are goi ng to  provide a user def ineddefaultconstruct o r , you sh oul d p rov ide t ha t in Spotting M a rker .c pp as w ell .
Spott ing Mar ker ::S po ttingMark er()
  :  m Po si ti on( 0)
 , mDuratio n( 0) ,  mD escri p tion(N ULL){ }
T hi r d,since y o ud e clar ed  a  des tru ct or in  Csv S pot tingNot es.h, you  sh o uldde fi ne it i n CsvSpotting No tes.cpp:
C sv Spo ttingN o t es::~Csv SpottingNotes() {
  //i mplemen tat ion h ere}

Thosesho uld be  al l  the d efinit ionsyo u n e e d, at l ea stac cording to y our  buil dlog. 
The la st thing I would n o teis that it do esn 't l o o klik e  y o urus i ngd e pendency inject ion in a t ra d it ional mann e r f or  threereasons .  Fi r st, typ ically wh en you do  d epen d e ncy  injection  you sto re a refe r encet othe i nje cted o bj ect  in t he rec e ive r obj ect so  t he rec eiver  c an use o ver the course of its l ifetim e.  H ere  you inje ctt hevector in to C svSpotting Not es,  butyou don't  sto r ea r e feren ce t o  it in th e  c las s ;  y ou just pus h a  sh aredpoi n ter on to i t.
Second
:
void push_shared_pointer(std::vector<boost::shared_ptr<int>_> &vector)_{
  boost::shared_ptr<int> int_ptr(new_int(5));
 _vector.push_back(int_ptr);
_ *int_ptr_=_6;
}

std::vector<boost::shared_ptr<int> > int_vector;
push_shared_pointer(int_vector);

std::cout_<< *int_vector.back( )_<< std::endl;

This outputs 6_because in the_function_since after we pushed the shared pointer onto the vector, we used the local_shared_pointer to_modify_the_referenced int.  Since the_shared pointer in the vector_and the_local shared pointer refer to the same memory_location,_both shared pointers_are updated.
As for the rest of the code, there_a few things to note. _First, the preprocessor_guards_were_an issue, as others_noted.  Second, you didn't scope_the function blah() in SopttingMarker.cpp to_tell the compile that it's an implementation_of the blah function in the_SpottingMarker class.  It should_read:
#include "SpottingMarker.h"

void_SpottingMarker::blah() { }

In addition, since_you indicated in_the header_that you are_going to provide a user defined_default constructor, you_should provide that in SpottingMarker.cpp as_well.
SpottingMarker::SpottingMarker()
_ : mPosition(0)
_,_mDuration(0)
_, mDescription(NULL)
{_}

Third, since you_declared_a destructor_in_CsvSpottingNotes.h, you should define it in_CsvSpottingNotes.cpp:
CsvSpottingNotes::~CsvSpottingNotes()_{
  // implementation here
}

Those should be_all the definitions you_need,_at least according to_your build log.
The last thing_I would note is that it_doesn't look_like your_using dependency injection in a traditional manner for three reasons. _First, typically when you do dependency_injection you store a_reference to_the_injected object in_the_receiver object_so the receiver can use over the_course of_its lifetime.  Here you inject_the vector into CsvSpottingNotes,_but_you don't store a reference to_it in the class; you just_push a shared pointer onto_it.
Second