Thanks for the kind words 
. Thought about teaching C++ actually, especially after learning a bit of metaprogramming which is an interesting topic in and of itself.
Well I certainly would want to learn c++ from you; I can’t stand not knowing how things work. Because you have to understand something to its core really to guitlessly explain it to someone like you know what you’re talking about. (which at that stage you are perhaps completely opinionless like Dan, from having seen it all)
To be honest I think you’d make a better engineer then teacher, but thats probably why your so concrete at explaining things, since you have the real skills and talent to teach it. I struggle to discover this stuff so my mind is blown that you’ve figured it out. (granted I’m sure you know your limits, and they just seem exceedingly high compared to mine)
At the same time perhaps you need the right kind of intelligence to explain it. My dads an engineer but hes a complete ******* when it comes to explaining anything. In fact sometimes hes so wrong I’m surprised hes still good at what he does.
But forgetting about that, the meta programming you mentioned, wow that alot to wrap one’s head around. In particularly since I have no clue the context in which it takes place. Hmm looking at it a bit more, it seems a bit more of a concept then well a new thing entirely? I’m seeing this guy filling in an exception for a function missing by writing code to make the function basically. Looking back at the definition on wiki i’m getting confused again though xD. I imagined initially perhaps you can tell a program to throw a ball it somehow writes it for you… ; detects you want to do physics on it, makes target locations, takes the initial location and the weight of a ball, makes some parameters you can later fill in, automatically makes an object that is the thrower… haha Idk I’m using my imagination to fill the void to much.
But Man, I should really get started on my game soon… I was really excited to understand all the concepts behind c++ when i started this course, but instead it operated more on a high-level language level of explanation. (despite c++ already being on a higher level to begin with, technically xD)
My memory needs refreshing from taking the modeling course, but I recall going into the primitive types and desperately wanting to know how they all operated. But simply going on wiki and searching the web as usual, proved difficult (this is why courses like these are so nice to have, even with the many flaws they still come with). Course Ben left many vital c++ keywords out of the course, which Im sure Dan would know about as useful for applications outside of Unreal; or even inside the application of Unreal projects; since you can code anything you want.
I’ve never been able to concretely say I know how to program , since every time i’ve learned it its been in the context of what I was working on, and not programming as a whole. (like understanding how the primitives are coded, I mean, sounds like a juicy topic does it not?)
Template metaprogramming is about moving runtime computations to compile time, the common example is factorial or fibbonaci
template<unsigned n>
struct factorial
{
enum { value = n * factorial<n - 1>::value };
};
template<> //specialisation
struct factorial<1>
{
enum { value = 1 }
}
factorial<4>::value //24
Due to how templates are instantiated the line of code at the bottom is a compile time computation. Of course in C++11 we gained constexpr so you can just write the function normally and mark it constexpr and it;ll achieve the same thing.
constexpr unsigned factorial(unsigned n)
{
return n == 1 ? 1 : n * factorial(n - 1);
}
Though this isn’t the only thing you can do with template metaprogramming.
template<typename T>
struct type_is { using type = T; }; //hand me a type, I give it back to you.
template<bool, typename T, typename> // third parameter unused, no need to name it
struct conditional : type_is<T> {}; //inherit from type_is<T>
template<typename T, typename F> //partial specialisation for false
struct conditional<false, T, F> : type_is<F> {}; //if false inherit from type_is<F>
std::conditional was added in C++14 and that’s how it can be implemented, so say you want to use type A if some conditional is true else use type B, conditional<someBool,int,float>::type Thing; if someBool is true, Thing is int, else it’s a float. And this is just the tip of the iceberg, far cooler things you can do
@sampattuzzi and @Michael_Bridges can you coordinate with each other to make the required cameos?
Ben and his tag-driven morse code 
my god you have alot of faces on this forum; haha.
even a face for poop, very nice. So any response as to why Dan seems way more experienced then you lol? I guess maybe hes unphased, oh wells. no biggie anyway, that is until Dan surpasses your course sales in his all new C++ course lol.
Dan is awesome, we are not worthy 
Alrite I’m back from the recursion grave, lol I fell asleep reading Dan’s post earlier because I think i need a review on template structure.
I didn’t even realize you could use enumerators to fetch values like that, let alone be used recursively.
I’ve only touched on recursion before and still havn’t seen any real use for it without making things just confusing. (maybe ben’s excuse not to mention it)
I’m still unsure of the point of the constexpr keyword too… But, I guess it makes your program more efficient while serving the same functionality as const? Since apparently for whatever benefit the values are evaluated during compile and not… during runtime. Which means… ?
… Ah i see I think you are trying to show one potenital benefit here… Except I still dont see why you need constexpr to do that. Im also a little unsure as to how this is meta programming. Well, I guess you are suggesting the example i saw is template meta programming, so idk. I guess the point is that its happening during compile time.
Now too look at your next example, heh, i’ve never came across the word using aside from using namespace.
Kind of confused how, well everything works there, lol. It is almost as though you are using the keyword conditional like its the name of the struct? hmm wait a minute, conditional is actually… your struct name? Well I have no clue what std::conditional has to do with anything lol.
My god its almost like your template is recurving into itself. lol a template structure that is a type of template structure with type T; really Dan?
So i guess, you’re telling it to change its type to … type F when you make the conditional with a false boolean… herm.
I’ve strayed off from this for too long doing modeling, and many programming concepts were left unsolidified or completely left out of the lectures.
Well one way or another, how would it benefit you to change to an int or a float based on some condition, and would it really be worth the hassle of setting up meta program templates for it?
I guess I really should be wanting to know other elements of c++ first heh, like I said, before making meta programs. Or i could be wrong idk, but there are several routes to doing things ofcourse.
Benjamin should really consult with Dan before Dan makes his course on his lonesome and the sales blow out of proportion. Haha, no seriously that would make a great course the two of you teaching c++, in particularly if its within the context where it prepares you for a practical purpose like game design, which would have various practices that transfer over to unreal, or maybe anything. Its nice to be able to code anything isnt it?
Part of the reason I dont go off and do c++ on its lonesome is because its often lacking context, or evidence of the skills being able to be transferred over to any or other applications, instead of being confined to the learned GUI or io-libraries , ect.
Compare the following code in compiler explorer Compiler Explorer. In the constexpr version a is initialised with the calculated value at compile time. The other creates the instructions for factorial and calls that function at runtime.
using has multiple uses that which is shown there is a template alias, so type is just an alias for whatever T is.
template<typename T, typename U>
using TMap = std::map<T, U>;
TMap<int,int> UE4Map; //std::map<int,int>
It’s using inheritence with metaprogramming, so I created a struct type_is which just holds a type alias called type for whatever the template parameter T is. Next is the name of a meta function which is just a class (struct) template which has 3 template parameters, a bool and two types. The “base” meta function just inherits from type_is<T> so it will have a type alias of type = T. Finally there’s a partial template specialisation where if the bool is false, which says inherit from type_is<F> instead. And this is a potential implementation of std::conditional
You could also just do
template<bool, typename T, typename>
struct conditional { using type = T; };
template<typename T, typename F>
struct conditional<false, T, F> { using type = F; };
I was just showing different metaprogramming techniques.
A simple example would be something like std::conditional<x < 0, int, unsigned>::type something; where it’ll be an int if x is negative else it’ll be unsigned. Also C++14 provided convience helper’s so you don’t have to do ::type or ::value all the time which is just ending the name with _t or _v, respectively i.e. std::conditional_t<x < 0, int, unsigned> something;