Hope you guys enjoyed the video! Just some quick notes: the code I wrote at around 10:30 needs some changes to actually work, since we've changed the type to a std::vector. Specifically, you could write either std::vector results(2); results[0] = vs; results[1] = fs; or just std::vector results; results.push_back(vs); results.push_back(fs); but leaving it as I left it wouldn't work, since we'd be writing to an index outside the array. Obviously in the video I'm just trying to get the point across about using an std::vector and not really trying to write complete working code, but just in case I thought I'd leave this comment.
Just for completions sake. For std::tuple you can return the value like a struct as well: return { vs, fs }; And with C++17 there is the option of structured bindings for tuples: const auto& [vs, fs] = ParseShader("res/shaders/Basic.shader"); std::cout
In this case it doesn't matter if you use emplace_back or push_back since the string has already been created. You can check out my video on this for more details: ruclips.net/video/HcESuwmlHEY/видео.html
For anyone reading recently, there's a better way with structured binding since c++17: Return a tuple of your choice and return it as per the video: std::tuple getData() { return { "One", "two", 3 }; } Retrieve values using structured binding: auto [str1, str2, number] = getData();
This is actually better than struct actually because with structs there are some issues with initialization and you need to maintain few things in certain scenarios. For example, try reading a csv file with header and try to put them in a struct so that they have different types for each of the column. structs are horrible to deal with.
@@slayer5171 Structs are simpler by a syntax pov. Class has some extra features that's not necessary here (constructors, etc...). Comparing if this solution, you have a cleaner code since you are removing a struct that's only used as a method response. I'm not sure about this, but I think you have a gain (not much I guess) in performance since you don't have to instantiate the struct itself. At the end of the day, I think it's only a syntax alternative.
at 13:20 It's worth noting that there are 2 more ways to make the code look somewhat better: In C++11 you can use something like: std::string vs, fs; tie(vs,fs) = ParseShader("directory...") // tie() is in the header And in C++17 you can even do: auto [vs, fs] = ParseShader("directory...") also instead of creating 2 strings at the end you can just return make_pair(vs, fs); or in C++17 return {vs, fs};
Год назад
Well, auto [vs, fs] = ParseShader("directory...") syntax not sound like a C++ at all. Adding a nail here and there just makes this already complicated language more complicated. ... C++ committee should just leave C++ alone 🥲
I think it will useful to keep these "optimization" parts in your video in the context you explain as a bonus for those (like you) who love it and try to create good optimized code. May be put them at the end of the video or display a little "sign" on the screen whe you speak about optimization if someone's complaining he's lost.
Tbh, if one actually writes a c++ program, then one should ALWAYS optimize. Why else would one go to such lengths as learning a huge multi leveled language like c++ instead of using for example c#? And for me personally that is actually the part of c++ which I love most.
Structs are obviously the best, but it can get a bit cluttered, so it should only be done if it's gonig to be used a number of times. Can't keep making new structs for every single thing. However, structured bindings are decent, aswell, even though it seems this video skipped over that...? At least, if you're doing this for member functions, you can declare the struct a member of the class, to avoid cluttering the namespaces. In such case, structs are definitely the best, no competition. It really is a shame that you can't declare the struct inside the function, and use the function name as a namespace...! That would be awesome.
I personally quite like 's std::tie function, not sure what that is like for performance but is a good way to have 2 named return types (of any type) without having go and write a struct for every function that requires multiple return types.
I'm really glad you use the struct way. I'm a newcomer to c++, i used to program in Java and I solved this problem by making classes with just what variables i needed to return. I'm happy now
Thank you so much for your indepth coverage of coding styles. As someone new to code you are making understanding c++ a very enjoyable experience. Great Job Cherno!
Interesting... I came to the same conclusions as you a few years back when checking the c++11 specifications. Thanks for informing us about your views.
Now would be a really good time to make a video on templates , because people who know c++ templates are gonna get this, but otherwise ..... Its must be like what's goin on man!!!!
Passing parameters it gives the impression that they are inputs. But, after you passing the beginner level, you can see the underlying flow and see that it can be used to pass multiple outputs. I agree with you. I think this is the best option, because it is simple to identify, if you choose a readable name for your parameter, and it is the fastest.
I guess structured bindings take away most of the readability-concerns at least on the caller-side. Returning something like a pointer to an array seems very odd to me and creates very bad habbits. That kind of usage can introduce very serious bugs, especially with inexperienced people. That's a thing I'd never recommend doing.
the struct solution is definitely the best way to solve this for huge amount of variables and calling by references is the best for variabel num up to 3
IMHO structs are the most natural and reliable way of handling functions with rich returns. Funnily enough that what I see most people who are not this advanced in c++ do. I feel like some very experienced people sometimes do things syntactically more complex just for sake of showing of 😃
I agree with you, returning struct seems like the best way. I also like 1st two methods, passing references/pointers as inputs and making updates to them in function. Other stuff you showed gets confusing quickly, mostly because I'm not that familiar with c++ library features. They keep adding new functionality I never seen before.
A very nice video, explanation. I would like to mention that if you are precise, the function that takes non const reference as argument and return nothing is the most performance friendly.
We will be able to return multiple values asynchronously in C++ 20 using coroutines. It would be great to see your opinion and explanation of those new features, after the new standard release.
You can enumerate the tuple position value to make it somewhat readable - std::get(John) - John is the tuple and "enum person(age = 0, ...)" for the enumerator
You can't conceive of an instance where one of the tuple library functions might be useful? Of course I like the struct semantics better and if I wanted to use the built in tuple functions I'd probably wrap it in a struct for semantic reasons. But, for drive-by programming, the enumerated tuple could work (as could the unenuerated tuple as used in the video).
well actually you can use brace initializers to initialize a returned pair just as well as you would for those aggregate classes. But I do agree with you on the clarity part. Used to like std::pair, and for some part in the stl there is no way around it, but when I looked at some older code of mine after a couple of month, it was quite hard to comprehend due to the first and second parts. Not even talking about tuple which I would advise to stay away from as much as possible
I create typedefs when parameters of same type are used for different things. This way it is easier to distinguish them. For example: typedef string Username; typedef string Password; void CreateUser(Username un, Password pw) Or use it as 2 parameters for your tuple in the video.
Ironically it's quite simple for a compiler to compile multiple returns down to an anonymous struct and pass the values into the chosen variables so this: "a, b, c = func()" would compile down to roughly "push push push call func mov c +3 mov b +2 mov a +1 pop pop pop" (though in a more assembly friendly then that)
I can't tell you how sad this makes me to hear. Tuple is such a powerful tool but so many people shy away from it simply because it's so unnecessarily messy to use.
if you have to write a list of types your function will return, why not just write a struct definition instead? A tuple template probably compiles down to the same thing in the end.
I like hearing you talk about memory stuff and by extension performance. I am very likely to never professionally work in c++ but much more likely to use Java. And while I don't need to know all this, I always do better if I can "get under hood." So while what your saying doesn't definitively apply to Java, it helps me understand why Java does what it does and how it does it and knowing that will help me grok the whole thing better.
I'm new to C++ (coming from Python), going through standard lib i checked library, I think its the most comfortable way to build multi-value return in C++, and its syntax compatible with C++ 17 (structured Binding), ``` #include std::tuple get_somthing() {return std::make_tuple(2, 3.3f, "abc");} then you call the above function like this: auto [a, b, c] = get_somthing(); //c++17 int a; float b; std::string c; std::tie(a, b, c) = get_somthing(); //c++11 ~ < 17 ```
THE LAST OPEN-GL AND THIS EPISODE WAS VERY DIFFICULT FOR ME . JUST TO SAY THAT I FOLLOWED YOU FROM SCRATCH BUT THIS ONE WAS A LITTLE MIXED STUFF . I DIDN'T UNDERSTAND THE SYNTAX MAYBE ITS TEMPLATES...
I think for generic stuff, pair and tuple is fine, though tuple syntax slightly clunky, and feel triple and quads should be a standard thing. For stuff used a lot, struct makes sense, but if I have a function called once or twice, I would just use a pair. Pass by reference would be the fastest, and preferred way in performance critical sections, but I don't like cluttering up function call if don't need performance.
Generally against returning pointers from functions using operator new, because now the caller has to remember to call delete at some point. Although you could use std::move with a unique_ptr
If Im returning a big complicated class I’ve built inside a function, I always define a new type that wraps the class in std::unique_ptr and return that created type. Writing move constructor/assignment functions does almost the same thing but its more tedious. The only downside is you might get better performance writing the constructors/assignments assuming the compiler will optimize away any copying/moving. I assume moving and dereferencing a unique_ptr isn’t much overhead though, since when you’re returning something big it usually isn’t in the inner-most loop where it would matter.
I personally hate std::tuple, std::pair, std::array, std::vector or array for return types like you do as well - i just use structs for multiple return types. It works fine and its totally clear what this function will return. Even for arrays i use a struct to include the number of items as well.
I almost always use the struct method, even across languages (possibly with a different name for the struct). I use passed in arguments in some cases, especially if the data was non-trivial, but would still likely wrap it in a struct or class; that would also be the one case where I might (rarely) use an array, in special, very circumstances.
yeah I'ld go with a struct too, if I use different types, otherwhise a vector/array has to do the job :s but really good to see other ways of dealing with this, will keep it in mind..
The struct way is great as long as you're not working with any crazy generic code. It could potentially get a little messy having to define a struct in the surrounding scope though.
Personally I prefer to use std::tuple and using std::tie() to organize return values. Or using auto [a, b, c, d] = get_data();, but unfortunately I'm not allowed to use this, because I'm tied and required to use C++11
I know VisualC++ or studio endup using the newest standards the last. But there is new way of handling it in C++17 via auto keyword, maybe wroth looking into when it will be added to non-preview version of visual studio/c++.
struct is the right way of doing it unless you are coding a (template) library and you don't know/care how the fields are named, then tuples are handy.
Hey Cherno, love your videos! In last part where you explained struct is the best way to return two values, how did it work by just returning { vs, fs} without allocating it into the heap?
This video seems a bit outdated even with respect to C++ 17, maybe it could be good to make an updated remake. Maybe when C++ 23 is out (idk if it has an impact on this).
I actually like using the struct more because it's organized and easy to read and also using vector using tuple maybe I didn't get so I kinda hate it since i follow the series of openGl
Great video as always, But we wont mind hearing about the optimization stuff you kept mentioning. Always felt I am missing something when you said you are not going to talk about optimizations.... I always watch your videos because they offer best practices which is more than syntax.
Me: It's pretty annoying that you can only ever return one thing... Cherno: Yeah so here's about 10 different ways off the dome you can do this 🤯 And that's why I'm here, to learn this stuff!
For std::tuple, what about putting enum ShaderType outside ParseShader(), then doing this:: auto sources = ParseShader("res/shaders/Basic.shader"); unsigned int shader = CreateShader(std::get(sources), std::get(sources));
8:05 you should put: return new std::string[2]{vs,fs}; because: return new std::string[]{vs,fs} gives me an error " error C3078: array size must be specified in new expressions"
The fast way… __asm__ (“mov Var1Reg, %%eax;” “mov Var2Reg, %%ebx;”); With an ASM function call on the other side to manage placing them where they need to be (or you can just place them there as your return if you know where you want them beforehand) Pretty ugly, but should be very fast because it can keep most of you data types in registers instead of pushing them to the stack This could be a poor choice of registers because it’s been a little while since I’ve worked with x86 assembly, but you can find that information from plenty of data sheets online if you are actually doing it this way.
Variable of large memory should be used by reference whatever are their number and the variable of small memory but more than one should by struct. Keep it cherno. Please tell about how file formats works making your own file formats. Mostly it is not spoken. Thanks.
When struct is returned by value does that mean that it is first created inside the function and then copied when returned to calling function? Is it better to return it as a reference?
Could you show us how to make your own file format? And how to save to file etc? I would like to create something simple like list of 3D vectors in binary format.
You said that std::array would allocate its space on the stack instead of the heap and std::vector which would make returning std::array faster. But, depending on implementation and compiler, wouldn't that depend on the number of elements? If it's allocated on the stack and returned the actual elements. The vector on the other hand doesn't that usually (implementation specific I assume) store like a pointer to the first actual element etc so that "definition" would be copied on return but not the actual elements (that are already on the heap and the receiving vector that takes the return value of the function could just point to those existing elements), depending on how clever the given compiler is I guess? I would go for the struct way in the example you give. I want my things to be named. Even though I can get away with it and even if I'm most likley to be the only one looking at my code I often try to think about it in a way that "IF someone else has to read this they should be able to figure it out". I have had instances where I have worked in system that has had stuff like if(ShowDialog(translator->string(156))->getReult() == translator->string(3749)) I have NO IDEA what the hell is going on. What question are we presenting to the user, what answer is it that makes us branch here??? I have to lookup translation files and understand the translation system etc. Drives me crazy and I want to murder people. Btw, JetBrains Resharper C++ edition is kind anice when one not always remembers the files something is defined in. Just write for instance "std::tuple foo;" alt+enter and let it include the file for you :)
@TheChernoProject Mr. Bjarne Stroustrup (Creator of C++) stated in his book (the c++ programming) over thousand times that prefer std::vector over std::array and even over C style arrays and he stated that it doesn't have any significant overhead in comparison to even C style Array. He stated that use std::vector as your default array container unless you have a good reason to choose another array container in c++. I really confused, it seems you're right and it has a lot of overhead specially in push_back method. but why Mr. Stroustrup strictly advised to use std::vector??? thank you for the amazing play-list
It does have a huge advantage if you don't need the absolute best performance available: it is much, much easier to work with and you won't have to use indexers
std::vector is ultra safe. And it's actually not recommended to use push_back() unless it's absolutely required. Define the vector, use resize() method to set it into the approximate size you'll need it to be and then use it like any other dynamic array. When you use optimizations("Release" in visual studio, "-O2 or -O3" in clang++ and g++) it really does achieve near std::array speeds and is exactly as efficient as c-style dynamic array.
This is the kind of stuff I'm talking about when I tell people how much I dislike C++. Why does everything always have to be so unclear to read? I agree that creating a wrapper struct is the best way to go because it makes everything 100% clear, but why do we have to do that? It's CRAZY when there already exists ways to implement this, but they are so poorly designed that it makes our code less readable. C# has tuples too, and in C# you can easily access the members just like a pair, but if you don't like to use .first and .second, YOU CAN PROVIDE WHATEVER CUSTOM NAMES YOU WANT. Creating a custom return type in C# just because you want to return 2 strings with readable names is CRAZY because the functionality is already there and it already provides you with ways to easily make it all 100% clear and readable. C++ really drives me up the wall...
Hope you guys enjoyed the video! Just some quick notes: the code I wrote at around 10:30 needs some changes to actually work, since we've changed the type to a std::vector. Specifically, you could write either
std::vector results(2);
results[0] = vs;
results[1] = fs;
or just
std::vector results;
results.push_back(vs);
results.push_back(fs);
but leaving it as I left it wouldn't work, since we'd be writing to an index outside the array. Obviously in the video I'm just trying to get the point across about using an std::vector and not really trying to write complete working code, but just in case I thought I'd leave this comment.
TheChernoProject In newer versions of C++ we would use emplace_back not push_back as the second creates unnecessary copys.
Just for completions sake. For std::tuple you can return the value like a struct as well:
return { vs, fs };
And with C++17 there is the option of structured bindings for tuples:
const auto& [vs, fs] = ParseShader("res/shaders/Basic.shader");
std::cout
In this case it doesn't matter if you use emplace_back or push_back since the string has already been created. You can check out my video on this for more details: ruclips.net/video/HcESuwmlHEY/видео.html
really??
Just wanted to stop by and say thanks. I realized I watch a bunch of your stuff and need to start saying thanks more often!
For anyone reading recently, there's a better way with structured binding since c++17:
Return a tuple of your choice and return it as per the video:
std::tuple getData() {
return { "One", "two", 3 };
}
Retrieve values using structured binding:
auto [str1, str2, number] = getData();
Much nicer, thank you
Why not use a class?
That's a nice syntax 👌
This is actually better than struct actually because with structs there are some issues with initialization and you need to maintain few things in certain scenarios. For example, try reading a csv file with header and try to put them in a struct so that they have different types for each of the column. structs are horrible to deal with.
@@slayer5171 Structs are simpler by a syntax pov. Class has some extra features that's not necessary here (constructors, etc...). Comparing if this solution, you have a cleaner code since you are removing a struct that's only used as a method response. I'm not sure about this, but I think you have a gain (not much I guess) in performance since you don't have to instantiate the struct itself. At the end of the day, I think it's only a syntax alternative.
at 13:20
It's worth noting that there are 2 more ways to make the code look somewhat better:
In C++11 you can use something like:
std::string vs, fs;
tie(vs,fs) = ParseShader("directory...") // tie() is in the header
And in C++17 you can even do:
auto [vs, fs] = ParseShader("directory...")
also instead of creating 2 strings at the end you can just return make_pair(vs, fs);
or in C++17 return {vs, fs};
Well, auto [vs, fs] = ParseShader("directory...") syntax not sound like a C++ at all. Adding a nail here and there just makes this already complicated language more complicated. ... C++ committee should just leave C++ alone 🥲
I think it will useful to keep these "optimization" parts in your video in the context you explain as a bonus for those (like you) who love it and try to create good optimized code. May be put them at the end of the video or display a little "sign" on the screen whe you speak about optimization if someone's complaining he's lost.
+1 to this!
Tbh, if one actually writes a c++ program, then one should ALWAYS optimize. Why else would one go to such lengths as learning a huge multi leveled language like c++ instead of using for example c#? And for me personally that is actually the part of c++ which I love most.
totally agree with you bro..
@@k-tech2937 I agree with you, Why use C++ when you don't want optimization.
i think structs and pass by reference methods are the best
I agree with you. I think for something with 2 return values I would use pass by reference but anything more than 2 I would probably make struct.
Structs are obviously the best, but it can get a bit cluttered, so it should only be done if it's gonig to be used a number of times. Can't keep making new structs for every single thing. However, structured bindings are decent, aswell, even though it seems this video skipped over that...?
At least, if you're doing this for member functions, you can declare the struct a member of the class, to avoid cluttering the namespaces. In such case, structs are definitely the best, no competition.
It really is a shame that you can't declare the struct inside the function, and use the function name as a namespace...! That would be awesome.
Actually, there's a way to do what I was talking about, using "auto" type deduction...
What if you’re dealing with recursion?
That’s what I do too.
I personally quite like 's std::tie function, not sure what that is like for performance but is a good way to have 2 named return types (of any type) without having go and write a struct for every function that requires multiple return types.
*My takeaways:*
1. Tuples 10:49
2. Pair 14:00
3. Struct 14:30
I'm really glad you use the struct way. I'm a newcomer to c++, i used to program in Java and I solved this problem by making classes with just what variables i needed to return. I'm happy now
for tuple you can easily extract value like auto [vertexSource, fragmentSource]=func() in c++ 17
I return std::optional with a struct. Typically you need to be able to return a valid structure or "nothing" and std::optional facilitates that.
Thank you so much for your indepth coverage of coding styles. As someone new to code you are making understanding c++ a very enjoyable experience.
Great Job Cherno!
I just want to say : C++17 Structured Bindings \o/
Cries in ue4 c++, cause no such elegant thing is available for ue4s internal data types
Interesting... I came to the same conclusions as you a few years back when checking the c++11 specifications. Thanks for informing us about your views.
Now would be a really good time to make a video on templates , because people who know c++ templates are gonna get this, but otherwise ..... Its must be like what's goin on man!!!!
yesss templates!
Coming Soon! (TM)
Passing parameters it gives the impression that they are inputs. But, after you passing the beginner level, you can see the underlying flow and see that it can be used to pass multiple outputs. I agree with you. I think this is the best option, because it is simple to identify, if you choose a readable name for your parameter, and it is the fastest.
I guess structured bindings take away most of the readability-concerns at least on the caller-side.
Returning something like a pointer to an array seems very odd to me and creates very bad habbits. That kind of usage can introduce very serious bugs, especially with inexperienced people. That's a thing I'd never recommend doing.
the struct solution is definitely the best way to solve this for huge amount of variables and calling by references is the best for variabel num up to 3
IMHO structs are the most natural and reliable way of handling functions with rich returns. Funnily enough that what I see most people who are not this advanced in c++ do. I feel like some very experienced people sometimes do things syntactically more complex just for sake of showing of 😃
I recently discovered std::pair at work. I've been using maps and I must say I really enjoy std::pair for that application.
I agree with you, returning struct seems like the best way. I also like 1st two methods, passing references/pointers as inputs and making updates to them in function.
Other stuff you showed gets confusing quickly, mostly because I'm not that familiar with c++ library features. They keep adding new functionality I never seen before.
Structured bindings from c++17 makes the tuple part a little nicer :)
A very nice video, explanation. I would like to mention that if you are precise, the function that takes non const reference as argument and return nothing is the most performance friendly.
My favorite ways are 1. Passing by Reference and 2. Using the struct.
Nice video thanks!
Cool. Thanks to make life easier. Enum is also good for return type.
love the casual setup! Makes me wanna come over and sit next to you while you explain things :)
To be honest this's the best setup :) and not even about setup the damn good explanation about the topic before diving in it, awesome.
i used an array when i was faced with returning multiple values, but the struct is a very good idea
We will be able to return multiple values asynchronously in C++ 20 using coroutines. It would be great to see your opinion and explanation of those new features, after the new standard release.
Thanks for sharing, I definitely need to read up on C++20
You can enumerate the tuple position value to make it somewhat readable - std::get(John) - John is the tuple and "enum person(age = 0, ...)" for the enumerator
the built in library functions come with the tuple
You can't conceive of an instance where one of the tuple library functions might be useful? Of course I like the struct semantics better and if I wanted to use the built in tuple functions I'd probably wrap it in a struct for semantic reasons. But, for drive-by programming, the enumerated tuple could work (as could the unenuerated tuple as used in the video).
well actually you can use brace initializers to initialize a returned pair just as well as you would for those aggregate classes. But I do agree with you on the clarity part. Used to like std::pair, and for some part in the stl there is no way around it, but when I looked at some older code of mine after a couple of month, it was quite hard to comprehend due to the first and second parts. Not even talking about tuple which I would advise to stay away from as much as possible
I create typedefs when parameters of same type are used for different things. This way it is easier to distinguish them. For example:
typedef string Username;
typedef string Password;
void CreateUser(Username un, Password pw)
Or use it as 2 parameters for your tuple in the video.
I like passing pointers or returning structs depending in the size of the struct. Sometimes I'll combine them and pass a pointer to a struct.
Ironically it's quite simple for a compiler to compile multiple returns down to an anonymous struct and pass the values into the chosen variables so this: "a, b, c = func()" would compile down to roughly "push push push call func mov c +3 mov b +2 mov a +1 pop pop pop" (though in a more assembly friendly then that)
I prefer the struct approach as well, self documenting .
Honestly, when I find myself thinking about busting out a tuple I usually just step back and try to figure out where my design went wrong.
I can't tell you how sad this makes me to hear.
Tuple is such a powerful tool but so many people shy away from it simply because it's so unnecessarily messy to use.
if you have to write a list of types your function will return, why not just write a struct definition instead? A tuple template probably compiles down to the same thing in the end.
I like hearing you talk about memory stuff and by extension performance. I am very likely to never professionally work in c++ but much more likely to use Java. And while I don't need to know all this, I always do better if I can "get under hood." So while what your saying doesn't definitively apply to Java, it helps me understand why Java does what it does and how it does it and knowing that will help me grok the whole thing better.
I'm new to C++ (coming from Python), going through standard lib i checked library, I think its the most comfortable way to build multi-value return
in C++, and its syntax compatible with C++ 17 (structured Binding),
```
#include
std::tuple get_somthing() {return std::make_tuple(2, 3.3f, "abc");}
then you call the above function like this:
auto [a, b, c] = get_somthing(); //c++17
int a; float b; std::string c;
std::tie(a, b, c) = get_somthing(); //c++11 ~ < 17
```
The optimization tidbits made the video better.
THE LAST OPEN-GL AND THIS EPISODE WAS VERY DIFFICULT FOR ME . JUST TO SAY THAT I FOLLOWED YOU FROM SCRATCH BUT THIS ONE WAS A LITTLE MIXED STUFF . I DIDN'T UNDERSTAND THE SYNTAX MAYBE ITS TEMPLATES...
Really enjoyed the style of this video, thank you!
I think for generic stuff, pair and tuple is fine, though tuple syntax slightly clunky, and feel triple and quads should be a standard thing. For stuff used a lot, struct makes sense, but if I have a function called once or twice, I would just use a pair. Pass by reference would be the fastest, and preferred way in performance critical sections, but I don't like cluttering up function call if don't need performance.
Generally against returning pointers from functions using operator new, because now the caller has to remember to call delete at some point. Although you could use std::move with a unique_ptr
If Im returning a big complicated class I’ve built inside a function, I always define a new type that wraps the class in std::unique_ptr and return that created type. Writing move constructor/assignment functions does almost the same thing but its more tedious. The only downside is you might get better performance writing the constructors/assignments assuming the compiler will optimize away any copying/moving. I assume moving and dereferencing a unique_ptr isn’t much overhead though, since when you’re returning something big it usually isn’t in the inner-most loop where it would matter.
I personally hate std::tuple, std::pair, std::array, std::vector or array for return types like you do as well - i just use structs for multiple return types. It works fine and its totally clear what this function will return. Even for arrays i use a struct to include the number of items as well.
I almost always use the struct method, even across languages (possibly with a different name for the struct). I use passed in arguments in some cases, especially if the data was non-trivial, but would still likely wrap it in a struct or class; that would also be the one case where I might (rarely) use an array, in special, very circumstances.
This is the 1st time I see you check out your phone notification. Getting distracted here a bit lol.
So... back to old fashion C style structs..... or like in Golang. Yeah... but the {a,b} part makes it C++ nicer.
I think the most optimised way would be to return a uintptr_t[] which will contain pointers to any values you want to return
yeah I'ld go with a struct too, if I use different types, otherwhise a vector/array has to do the job :s but really good to see other ways of dealing with this, will keep it in mind..
An STL container comparison video would be cool,
And main algorithms
The struct way is great as long as you're not working with any crazy generic code. It could potentially get a little messy having to define a struct in the surrounding scope though.
Are you planning to make some videos on DESIGN PATTERN in C++???
Personally I prefer to use std::tuple and using std::tie() to organize return values. Or using auto [a, b, c, d] = get_data();, but unfortunately I'm not allowed to use this, because I'm tied and required to use C++11
I know VisualC++ or studio endup using the newest standards the last. But there is new way of handling it in C++17 via auto keyword, maybe wroth looking into when it will be added to non-preview version of visual studio/c++.
I learned some new things! Nice video.
struct is the right way of doing it unless you are coding a (template) library and you don't know/care how the fields are named, then tuples are handy.
Hey Cherno, love your videos! In last part where you explained struct is the best way to return two values, how did it work by just returning { vs, fs} without allocating it into the heap?
ive waited so long for a continue of this c++ series
In c++ 17 you can access touple like this without the get method, I don’t like it either.
std::tuple tt{5,10.3};
auto &&[ff,ss] = tt;
std::cout
tbf we could actually write up tagged tuples extending the standard tuples, the smoothest form I've seen it in requires constexpr and macros tho.
thanks, used struct to solve my problem 😆
Why can't we create a static array and return it in a function with a return type of array? Please help. Thanks.
You can, but this is not what the video is about: it's about returning multiple values of a *different type* .
you are a very good teacher! thanks
This video seems a bit outdated even with respect to C++ 17, maybe it could be good to make an updated remake. Maybe when C++ 23 is out (idk if it has an impact on this).
Could you do a video about exception handling and / or scheduling and mutual exclusion?
Shayan Shajarian Look in cs 162. Best OS course!
Structured binding is now a thing in C++17.
How about tuples and pairs using std::tie and structured bindings?
Great video as always!!!! Could you make a video about time complexity in C++?
How is time complexity related to C++?
Setup is cool 😎
I actually like using the struct more because it's organized and easy to read
and also using vector
using tuple maybe I didn't get so I kinda hate it since i follow the series of openGl
Great video as always, But we wont mind hearing about the optimization stuff you kept mentioning. Always felt I am missing something when you said you are not going to talk about optimizations.... I always watch your videos because they offer best practices which is more than syntax.
Me: It's pretty annoying that you can only ever return one thing...
Cherno: Yeah so here's about 10 different ways off the dome you can do this 🤯
And that's why I'm here, to learn this stuff!
For std::tuple, what about putting enum ShaderType outside ParseShader(), then doing this::
auto sources = ParseShader("res/shaders/Basic.shader");
unsigned int shader = CreateShader(std::get(sources), std::get(sources));
I think this is how UE4 passes data, use structure to bundle stuff all the time.
I'm a fan of passing in a variable reference OR returning a struct. The other options just don't feel right.
Right!?...
Elegancko
Q. Why do you not use it much yourself? Return via. structs and pass by ref?
My methods mostly return objects or structs when i need to deal with more than a single value
One thing I don't get, is in the return he initialized a struct but the struct had no parametised constructor?
8:05 you should put:
return new std::string[2]{vs,fs};
because:
return new std::string[]{vs,fs} gives me an error "
error C3078: array size must be specified in new expressions"
I dont know which standard you are using but Structured Bindings would be the best option in my opinion.
It's extremely new and not really supported everywhere yet, so I tend to avoid it.
The fast way…
__asm__ (“mov Var1Reg, %%eax;”
“mov Var2Reg, %%ebx;”);
With an ASM function call on the other side to manage placing them where they need to be (or you can just place them there as your return if you know where you want them beforehand) Pretty ugly, but should be very fast because it can keep most of you data types in registers instead of pushing them to the stack
This could be a poor choice of registers because it’s been a little while since I’ve worked with x86 assembly, but you can find that information from plenty of data sheets online if you are actually doing it this way.
i will come back after i watch OpenGL series .. now i have no clue
Variable of large memory should be used by reference whatever are their number and the variable of small memory but more than one should by struct. Keep it cherno.
Please tell about how file formats works making your own file formats. Mostly it is not spoken. Thanks.
awesome!
I prefer the strict approach
I think using struct is better to deal with multiple return values instead of using tuple.
I thought making struct was the only way to return multiple values..and thought it was uncomfortable.
What IF I want to return only one value, but it being one of two types?
Say a string OR a bool?
I use std::variant for this.
structured bindings
When struct is returned by value does that mean that it is first created inside the function and then copied when returned to calling function? Is it better to return it as a reference?
Could you show us how to make your own file format? And how to save to file etc? I would like to create something simple like list of 3D vectors in binary format.
Totally out of my league at this time .
You said that std::array would allocate its space on the stack instead of the heap and std::vector which would make returning std::array faster. But, depending on implementation and compiler, wouldn't that depend on the number of elements?
If it's allocated on the stack and returned the actual elements. The vector on the other hand doesn't that usually (implementation specific I assume) store like a pointer to the first actual element etc so that "definition" would be copied on return but not the actual elements (that are already on the heap and the receiving vector that takes the return value of the function could just point to those existing elements), depending on how clever the given compiler is I guess?
I would go for the struct way in the example you give. I want my things to be named. Even though I can get away with it and even if I'm most likley to be the only one looking at my code I often try to think about it in a way that "IF someone else has to read this they should be able to figure it out". I have had instances where I have worked in system that has had stuff like
if(ShowDialog(translator->string(156))->getReult() == translator->string(3749))
I have NO IDEA what the hell is going on. What question are we presenting to the user, what answer is it that makes us branch here??? I have to lookup translation files and understand the translation system etc. Drives me crazy and I want to murder people.
Btw, JetBrains Resharper C++ edition is kind anice when one not always remembers the files something is defined in. Just write for instance "std::tuple foo;" alt+enter and let it include the file for you :)
at 10:05, array on the stack, vector on heap. Can somebody tell me why it is?
@TheChernoProject
Mr. Bjarne Stroustrup (Creator of C++) stated in his book (the c++ programming) over thousand times that prefer std::vector over std::array and even over C style arrays and he stated that it doesn't have any significant overhead in comparison to even C style Array. He stated that use std::vector as your default array container unless you have a good reason to choose another array container in c++.
I really confused, it seems you're right and it has a lot of overhead specially in push_back method.
but why Mr. Stroustrup strictly advised to use std::vector???
thank you for the amazing play-list
It does have a huge advantage if you don't need the absolute best performance available: it is much, much easier to work with and you won't have to use indexers
std::vector is ultra safe. And it's actually not recommended to use push_back() unless it's absolutely required. Define the vector, use resize() method to set it into the approximate size you'll need it to be and then use it like any other dynamic array. When you use optimizations("Release" in visual studio, "-O2 or -O3" in clang++ and g++) it really does achieve near std::array speeds and is exactly as efficient as c-style dynamic array.
7:13 probably error. You return address of string placed in stack, which be destroyed at the end of function block
If you need to use pointers, consider using shared_ptr or unique_ptr at this case
This is the kind of stuff I'm talking about when I tell people how much I dislike C++.
Why does everything always have to be so unclear to read?
I agree that creating a wrapper struct is the best way to go because it makes everything 100% clear, but why do we have to do that? It's CRAZY when there already exists ways to implement this, but they are so poorly designed that it makes our code less readable.
C# has tuples too, and in C# you can easily access the members just like a pair, but if you don't like to use .first and .second, YOU CAN PROVIDE WHATEVER CUSTOM NAMES YOU WANT.
Creating a custom return type in C# just because you want to return 2 strings with readable names is CRAZY because the functionality is already there and it already provides you with ways to easily make it all 100% clear and readable.
C++ really drives me up the wall...
What about a templates in CPP video ?
You returned a struct so that was copied, right? Is copying better then allocating on the heap?