How to Deal with Multiple Return Values in C++
Вставка
- Опубліковано 2 жов 2024
- Patreon ► / thecherno
Twitter ► / thecherno
Instagram ► / thecherno
Discord ► thecherno.com/...
Series Playlist ► thecherno.com/cpp
Thank you to the following Patreon supporters:
Samuel Egger
Dominic Pace
Kevin Gregory Agwaze
Sébastien Bervoets
Tobias Humig
Peter Siegmund
Gear I use:
-----------------
BEST laptop for programming! ► geni.us/pakTES
My FAVOURITE keyboard for programming! ► geni.us/zNhB
FAVOURITE monitors for programming! ► geni.us/Ig6KBq
MAIN Camera ► geni.us/t6xyDRO
MAIN Lens ► geni.us/xGoDWT
Second Camera ► geni.us/CYUQ
Microphone ► geni.us/wqO6g7K
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: ua-cam.com/video/HcESuwmlHEY/v-deo.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.
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 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.
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 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
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)
Structured bindings from c++17 makes the tuple part a little nicer :)
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 return std::optional with a struct. Typically you need to be able to return a valid structure or "nothing" and std::optional facilitates that.
*My takeaways:*
1. Tuples 10:49
2. Pair 14:00
3. Struct 14:30
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 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...
for tuple you can easily extract value like auto [vertexSource, fragmentSource]=func() in c++ 17
i used an array when i was faced with returning multiple values, but the struct is a very good idea
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++.
An STL container comparison video would be cool,
And main algorithms
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).
... and C++20 has not improved on tuples. Structs are definitely the way to go.
thanks, used struct to solve my problem 😆
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.
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
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 :)
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.
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?
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.
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* .
I recently discovered std::pair at work. I've been using maps and I must say I really enjoy std::pair for that application.
Cool. Thanks to make life easier. Enum is also good for return type.
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"
Totally out of my league at this time .
Are you planning to make some videos on DESIGN PATTERN in C++???
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!
13:54
#include
#include
class Sigma
{
public:
float x, y, z;
Sigma(float p_x, float p_y, float p_z) : x(p_x), y(p_y), z(p_z) {}
const std::tuple GetValues() const {
return std::make_tuple(x, y, z);
}
};
int main() {
Sigma sigma(1.0f, 2.0f, 3.0f);
auto values = sigma.GetValues();
std::cout
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 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.
I think using struct is better to deal with multiple return values instead of using tuple.
How about tuples and pairs using std::tie and structured bindings?
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));
This is the 1st time I see you check out your phone notification. Getting distracted here a bit lol.
i will come back after i watch OpenGL series .. now i have no clue
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
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...
Want to return 2 32 bit integer while only returning 1 value?
put the first value in a 64-bit integer and shift it left by 4 bytes so it occupies the 32 most significant bits.
Put the second value in a 64-bit integer so it occupies the 32 least significant bits.
Return the OR of these two.
Now to get your two 32-bit values back just AND the returned value with 0xFFFFFFFF00000000 and 0x00000000FFFFFFFF respectively.
For the record I don't advice doing this
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.
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.
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
Casual style is better thats why I don't watch Derek Banas because he has a monotone voice and is super boring
Poor Derek Banas. :(
Other methods of returning multiple values? Well, you could use a loopback socket....
Don't do that tho. XD
So... back to old fashion C style structs..... or like in Golang. Yeah... but the {a,b} part makes it C++ nicer.
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.
Hey! , Why an OpenGL video is on C++ Series??, Is this part of C++ Series
Im skipping this one
not a big fan of this video because I have no clue what any of the prewritten code is. yes, i could watch his other video, but i'm not trying to learn game design
I love Python. The syntax is beautiful and reading it is much easier than C or C++ for me. I just wish it were fast 😭. Most of the time, if I need speed I'd just use Cython, but right now I need to use C++. Time to learn the differences between the 18 different ways to initialize variables I guess... And deal with crap like not being able to index into a tuple... And not having basic functionality like splitting a string on a delimiter in the standard library.
Edit: great videos BTW. I'd be completely lost without them!
Yeah, python is easier to read and write and helps in fast development...And C++ feels clumsy to someone who has first learnt python. But once u get used to C++/C you would want to code into it..because the power it provides U. I sometimes use python for prototyping and then use C++ for actual codes. BTW a language is just a tool but sometimes beautiful tools make you fall in love with them...and that is C++.
@@ABHISHEKSINGH-nv1se yeah, I get it. I've been coding in both C++/C and Python for a while although I definitely have more Python experience. I think it's hard to argue that C++ code is (on average) more beautiful than Python code, although I understand aesthetics can be subjective. For me, the main appeal of C++ is the speed. Also it's better for dealing with low level stuff like drivers, I believe. Also, I feel like libraries can often make a much bigger difference in programmer experience than the language even.
You returned a struct so that was copied, right? Is copying better then allocating on the heap?
One thing I don't get, is in the return he initialized a struct but the struct had no parametised constructor?
Could you do a video about exception handling and / or scheduling and mutual exclusion?
Shayan Shajarian Look in cs 162. Best OS course!
i wonder what kind of shit they smoking while developing those stl collections..damn
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
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.
at 10:05, array on the stack, vector on heap. Can somebody tell me why it is?
Al those fancy C++ methods only to return to plain old C-struct.
In python you can automatical... automagically ...
LOL
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.
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.
10:05 being said std::array is allocated on stack, 8:55 why won't it be a dangling pointer out of the function scope as if I were to return a int* which maybe holds a int arr[] ? I am guessing this std::array will have a copy to another memory location which maintain the values inside?
@Peterolen thx
at 12:25, why not use `std::make_tuple` instead?
Right!?...
Structured binding is now a thing in C++17.
TL;DR, did not watch, but I clicked through. You went from array of string to pair. You could also run with tuple for that matter, not sure if you mentioned that. std::tuple, std:::tie, pretty simply.
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)
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
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 😃
When returning a stack created object like a std::vector from a function, will It be copied at the receiving end? like :
std::vector a = createVector(5); //createVector(unsigned size_t size) returns randomly filled vector of size size
This is the kind of place where we use Move semantics right?
After learning python c++ is so annoying XD
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!
I learned some new things! Nice video.
The struct.... Just the struct .... The others are just noo........
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
Pause your video and go to 1:50 "I am high on stack"
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.
I think this is how UE4 passes data, use structure to bundle stuff all the time.
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
```
I think the most optimised way would be to return a uintptr_t[] which will contain pointers to any values you want to return
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?
I thought making struct was the only way to return multiple values..and thought it was uncomfortable.
Q. Why do you not use it much yourself? Return via. structs and pass by ref?
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.
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.
can you explain this code in another video and i didn't understand anything though i saw the video three times can you expain it
I'm a fan of passing in a variable reference OR returning a struct. The other options just don't feel right.
Well how about a vector of void*
Can you please make a new project for every new tutorial? Im a beginer and it is imposible for me understand it, sorry but I cant watch that video 😞😓
05:57 could one just assign ss[0].str() to vertexSource? and the same for fragmentSource.. so fragmentSource = ss[1].str(); ?
The optimization tidbits made the video better.
Hi, if std::array allocates memory on stack, how do you return it then?
Could you explain how memory management works at the hardware level? The heap has never really made sense to me.
my school does c++ but i learn from youtubers how to code, and my TA sometimes, but he is overworked
My favorite ways are 1. Passing by Reference and 2. Using the struct.
Nice video thanks!