Just pressing the run button doesn't work

File is flagged eof only after reading function found eof. If you read all bytes fron a file and stop, it is technically not eof situation

vector<string>::const_iterator I guess

of which type is b when a is of type const std::vector<std::string>? auto b = a.begin();

const iterator

Nope

why the standard library doesn't has such a construct: to make the compiler decide whether to pass by value or reference instead of just passing by const T& because we don't know what the user will pass template<typename, bool> struct OptimizedType; template<typename T> struct OptimizedType<T, true> { using type = const T&; }; template<typename T> struct OptimizedType<T, false> { using type = T; }; template<typename T> using OptTypeT = typename OptimizedType<T, (sizeof(T) > 8)>::type; then the user will just define his function like this template<typename T> void test(OptTypeT<T> value){}

of which type is b when a is of type const std::vector<std::string>? auto b = a.begin();

decltype(a)::iterator

Decltype(a)::const_iterator?

Please help me understand in which case can this be true void main() { }

What are you trying to optimize? I guess in general there are too many edge cases to have a "generalized" type. Also the size heavily depends on your platform and might be be faster to pass Foo below by value than by reference. struct Foo { uint64_t x; uint64_t y; };

Okay So let's make it sizeof(T) > sizeof(T*) Isn't that okay?

> "[The main] function [...] shall have a declared return type of type int" http://eel.is/c++draft/basic.start.main#2

but might still pass a trivial structure such as the one above by reference instead of value, whereas passing it by value might be faster

So What do you suggest?! We sometimes just type const T& just because we don't know what type the user will pass

It's C++ after all, it always depends on the concrete case :)

So it’s always int main()

why the standard library doesn't has such a construct: to make the compiler decide whether to pass by value or reference instead of just passing by const T& because we don't know what the user will pass template<typename, bool> struct OptimizedType; template<typename T> struct OptimizedType<T, true> { using type = const T&; }; template<typename T> struct OptimizedType<T, false> { using type = T; }; template<typename T> using OptTypeT = typename OptimizedType<T, (sizeof(T) > 8)>::type; then the user will just define his function like this template<typename T> void test(OptTypeT<T> value){}

Some explain to me the usage of ? And :

Whereas using references extern void RBar(const Foo& foo); void RQux(const Foo& foo) { RBar(foo); } would compile into a single jmp RQux(Foo const&): jmp RBar(Foo const&)

std::forward my dude

So basically you are saying that sometimes passing by value for small size type is slower than by reference?

There are cases where the code generated is worse (most likely due to ABI requirements imposed by the underlying platform). I would suggest to benchmark it to see the performance impact

best would be remove winblows, install GNU/Linux, I'd say fedora or openSUSE, install gcc, build-essentials, etc. vscode and get started

You just told her to install linux as if it was installing a videogame XD

Do you know any good naming conventions discussing naming of boolean member variables describing states. I mean class Calculator { bool finished; // 1 bool isFinished; // 2 bool hasFinished; // 3 };

/cbook

Do you know any good naming conventions discussing naming of boolean member variables describing states. I mean class Calculator { bool finished; // 1 bool isFinished; // 2 bool hasFinished; // 3 };