Q:

c++ error LNK1120: 1 unresolved externals on calling inside of static function

i have a problem with calling a template function inside of a static method.
here my codes:
baseEvent.h
#ifndef BASE_EVENT_H
#define BASE_EVENT_H

#include <unordered_map>
#include <functional>

class baseEvent
{
public:
    template<typename Sender,typename EventArgs>
    using pureEvent = std::function<void(Sender, EventArgs)>;
    template<typename pureEvent>
    using eventMap = std::unordered_map<int, pureEvent>;

    template<typename Sender, typename EventArgs>
    struct Event
    {
        int AddEvent(pureEvent<Sender, EventArgs>);
        void RemoveEvent(int);
        void LaunchEvents(Sender, EventArgs);
    private:
        eventMap<pureEvent<Sender,EventArgs>> Events;
    };
};

#endif

and baseEvent.cpp
    #include "baseEvent.h"

template <typename Sender, typename EventArgs>
int baseEvent::Event<Sender, EventArgs>::AddEvent(pureEvent<Sender, EventArgs> pure_event)
{
    auto uniqeID = 0;
    if (Events.rbegin() != Events.rend())
        uniqeID = Events.rbegin()->first + 1;
    Events.insert(std::make_pair(uniqeID, pure_event));
    return uniqeID;
}

template <typename Sender, typename EventArgs>
void baseEvent::Event<Sender, EventArgs>::RemoveEvent(int uniqeID)
{
    auto it = Events.find(uniqeID);
    if (it != Events.end())
        Events.erase(it);
}

template <typename Sender, typename EventArgs>
void baseEvent::Event<Sender, EventArgs>::LaunchEvents(Sender sender, EventArgs e)
{
    if (Events.empty())return;
    for (auto& singleEvent : Events)
    {
        singleEvent(sender, e);
    }
}

anotherClass.h
    #include "baseEvent.h"
class anotherClass
{
public:
    typedef baseEvent::pureEvent<nullptr_t, int> ballEvent;

    static void Update();

    static int AddOnChangeOwnerEvent(ballEvent);
    static void RemoveOnChangeOwnerEvent(int);
    static void LaunchOnChangeOwnerEvents(int);
private:
    static baseEvent::Event<nullptr_t, int> OnChangeOwnerEvents;
};

anotherClass.cpp
#include "anotherClass.h"

baseEvent::Event< nullptr_t, int> ball::OnChangeOwnerEvents;

void ball::Update()
{
    LaunchOnChangeOwnerEvents(0);
    //.
    //.
    //.
}

inline int anotherClass::AddOnChangeOwnerEvent(ballEvent ball_event)
{
    return OnChangeOwnerEvents.AddEvent(ball_event);
}

inline void anotherClass::RemoveOnChangeOwnerEvent(int uniqeID)
{
    return OnChangeOwnerEvents.RemoveEvent(uniqeID);
}

inline void anotherClass::LaunchOnChangeOwnerEvents(int event_args)
{
    return OnChangeOwnerEvents.LaunchEvents(nullptr, event_args);
}

it gives me this error :

Error 2   error LNK2019: unresolved external symbol "public: void
  __thiscall baseEvent::Event::LaunchEvents(std::nullptr_t,int)"
  (?LaunchEvents@?$Event@$$TH@baseEvent@@QAEX$$TH@Z) referenced in
  function "public: static void __cdecl
  anotherClass::LaunchOnChangeOwnerEvents(int)"
  (?LaunchOnChangeOwnerEvents@ball@@SAXH@Z) E:\projects\ProFCEngine\SoccerAI\anotherClass.obj   SoccerAI

it should work fine ,what i did wrong?
UPDATE
if i use template struct baseEvent::Event; LaunchOnChangeOwnerEvents will fix but if i do this in my main i get error again.
 #include "anotherClass.h"

 int main()
 {
         anotherClass c;
        ball::AddOnChangeOwnerEvent([](nullptr_t sender, int args)
        {
            std::cout << "here";
        });
         c.Update();

         return 0;
  }

A:

Too long did not read
The simplest solution is to add the following line at the end of baseEvent.cpp
template struct baseEvent::Event<nullptr_t, int>;

Answer
Let's assume that your main looks like this:
 #include "anotherClass.h"

 int main()
 {
         anotherClass c;

         c.Update();

         return 0;
  }

When we compile main.cpp
 g++ -std=c++11 -c main.cpp -o main.o

And check what symbols our translation unit needs/provides:
 $nm -gC main.o
 0000000000000000 T main
                  U anotherClass::Update()

main.cpp needs implementation of anotherClass::Update.
let's compile anotherClass.cpp
 g++ -std=c++11 -c anotherClass.cpp -o anotherClass.o

And again check what symbols our translation unit needs/provides:
$nm -gC anotherClass.o
[...]
0000000000000000 T anotherClass::Update()
                 U baseEvent::Event<decltype(nullptr), int>::LaunchEvents(decltype(nullptr), int)
[...]

anotherClass.cpp provides a lot of symbols I have removed them for clarity. As you can see during anotherClass.cpp compilation LaunchEvents for nullptr_t, int was not compiled, because compilator didn't have its definition.
When we check what baseEvent.o with nm we will learn it did not provide any symbols nor needs any.
nm -gC baseEvent.o

As I have written before the problem is that anotherClass.cpp have only declaration of LaunchEvents not is definition.
Explicit instantiation
The first way to go is to force instantiation of this template in baseEvent.cpp:
template struct baseEvent::Event<nullptr_t, int>;

If we check baseEvent.o after such change we will see that needed symbols will be provided in this translation unit:
$nm -gC baseEvent.o
[...]
0000000000000000 W baseEvent::Event<decltype(nullptr), int>::RemoveEvent(int)
0000000000000000 W baseEvent::Event<decltype(nullptr), int>::LaunchEvents(decltype(nullptr), int)
0000000000000000 W baseEvent::Event<decltype(nullptr), int>::LaunchEvents(baseEvent::Event<decltype(nullptr), int>, int)
0000000000000000 W baseEvent::Event<decltype(nullptr), int>::AddEvent(std::function<void (decltype(nullptr), int)>)
0000000000000000 W baseEvent::Event<decltype(nullptr), int>::AddEvent(std::function<void (baseEvent::Event<decltype(nullptr), int>, int)>)
[...]

Moving template definition to header
As @qxz stated in his/her answer you can move template implementation to the header. You can add inline function after class
#ifndef BASE_EVENT_H
#define BASE_EVENT_H

#include <unordered_map>
#include <functional>

class baseEvent
{
public:
[...]

    template<typename Sender, typename EventArgs>
    struct Event
    {
        int AddEvent(pureEvent<Sender, EventArgs>);
        void RemoveEvent(int);
        void LaunchEvents(Sender, EventArgs);
    private:
        eventMap<pureEvent<Sender,EventArgs>> Events;
    };
};

[...]

template <typename Sender, typename EventArgs>
inline void baseEvent::Event<Sender, EventArgs>::LaunchEvents(Sender sender, EventArgs e)
{
    if (Events.empty())return;
    for (auto& singleEvent : Events)
    {
        singleEvent.second(sender, e);
    }
}

#endif

Or add the implementation inside class definition
class baseEvent
{
public:
    [...]

    template<typename Sender, typename EventArgs>
    struct Event
    {
        [...]
        void LaunchEvents(Sender sender, EventArgs e)
        {
                if (Events.empty())return;

                for (auto& singleEvent : Events)
                {
                    singleEvent.second(sender, e);
                }
        }
    private:
        eventMap<pureEvent<Sender,EventArgs>> Events;
    };
};

If you do so the implementation will be provided in anotherClass.o:
$ nm -gC anotherClass.o  | grep LaunchEvent
0000000000000000 W baseEvent::Event<decltype(nullptr), int>::LaunchEvents(decltype(nullptr), int)
0000000000000000 W baseEvent::Event<decltype(nullptr), int>::LaunchEvents(baseEvent::Event<decltype(nullptr), int>, int)

