Q:

UE4 - Object has reflection - why to use C++ then? 

I have always thought that UE is faster than Unity as UE uses C++ and Unity C#.  C++'s philosophy seems to be broken here, which is you pay for the things you use.  Now reflection and garbage collection is added.  So why should UE4 be faster if they made from C++ another C#? 

A:

I'm not sure if this is a complete answer, I have attempted to show why both Unreals reflection and it's GC do not mean it has to be as slow as C#.  
Reflection
C# has a very powerful reflection system that allows you to do a number of crazy things at run time (constructing generic classes, generating functions).  This is because C# is compiled into a byte code which is the Just-in-time (JIT) compiled in to the machine code that gets executed.  A lot of the reflection is implemented in the common language interface (CLI)1.  This comes at a speed expense - the code has to be compiled at run time and as a result can undergo less aggressive optimisations (less time to do them as user is waiting for the program to start).  
The reflection system in Unreal, on the other hand, is implemented at compile time by generating a load of code that is then also compiled by the same C++ compiler.  Of course if you make extensive use of this reflection system (calling functions by name, accessing properties dynamically), it will be slower than if you didn't and you will lose at lot of compile time optimisations on that code.  But if you don't and you just occasionally get the type of a class, then the main cost you will pay for the reflection system is simply the size of your binary (and the compilation time).  
Garbage Collection
I don't know the details of Unreals Garbage Collection system, so this section may be incomplete.  Typically, the reason why game developers care about GC (or the lack thereof) is:

GC'd languages can be wasteful when you have a lot of rapid allocations/deallocations2.  In C++ you can allocate on the stack (which is faster3) when you know the data is going to be thrown away shortly. 
You (the developer) don't know when a GC will be triggered which can cause a break in the smooth frame rate.  Normally, developers prefer to control when garbage collection happens. 

Unreal can avoid the first problem as only UObjects are GC'd anyway.  This means you can still use normal classes without worrying about the garbage collector and happily allocate on the stack when appropriate.  
For the second point, I'm not certain how GC is implemented in Unreal but it is certainly imaginable that they have considered this and have a way to side-step the hitches.  

In conclusion, Unreal is still able to use features that allow C++ to be faster than C# (more aggressive optimisation, stack allocation) even with the basic version of reflection and GC that it has.  
1: How is reflection implemented in C#? 
2: Examples of wasteful heap allocations
3: Which is faster: Stack allocation or Heap allocation

