My 2 cents:
As eXpl0it3r already mentioned, use RAII and smart pointers. Don't call new/delete yourself (you almost
never need to), instead use std::make_unique and std::make_shared when you need to allocate on the heap. If you are not using C++14 but are stuck with C++11 then you will unfortunately be lacking std::make_unique, but you can easily implement it yourself (basically you can just copy the template directly from the text of the standard; just don't put it in namespace std). If you don't want to do that, then at least make calls to new go directly into the smart pointer in a statement that does nothing else
auto ptr = std::unique_ptr<someType>(new someType);
.
Don't do stuff like creating the smart pointer as part of a function call etc, since this may leak if the compiler evaluates function call arguments in an unfortunate order (new called first, other funtion evaluated that throws, then assigning of new result to smart pointer ctor) - the std::make_... functions avoid this problem.
Prefer allocating objects on the stack rather than on the heap. Stack allocated objects are automatically destroyed when you leave the scope they are defined in, regardless of how you leave that scope. Stack variable are also often more CPU cache friendly.
Define variables in as narrow a scope as their lifetime needs dictate and no wider.
Use tools such as Valgrind, clang-analyze and the Google/LLVM/GNU sanitizers to help you find mem leak issues in your current code.
Don't use global variables. Their lifetime is the lifetime of the program and they will take up memory for the entire duration of the program (although that's really the least of their problems).
