Returning multiple values from a C function

Question

Is there a preferred way to return multiple values from a C   function   For example  imagine a function that divides two integers and returns both the quotient and the remainder   One way I commonly see is to use reference parameters   void divide int dividend  int divisor  int amp  quotient  int amp  remainder     A variation is to return one value and pass the other through a reference parameter   int divide int dividend  int divisor  int amp  remainder     Another way would be to declare a struct to contain all of the results and return that   struct divide result       int quotient      int remainder      divide result divide int dividend  int divisor     Is one of these ways generally preferred  or are there other suggestions   Edit  In the real-world code  there may be more than two results   They may also be of different types

User · Answer

I would just do it by reference if it s only a few return values but for more complex types you can also just do it like this     static struct SomeReturnType  int a b c  string str   SomeFunction       return  1 2 3 string  hello world        make sure you return values in the right order      use  static  to limit the scope of the return type to this compilation unit if it s only meant to be a temporary return type     SomeReturnType st   SomeFunction     cout  lt  lt   a      lt  lt  st a  lt  lt  endl   cout  lt  lt   b      lt  lt  st b  lt  lt  endl   cout  lt  lt   c      lt  lt  st c  lt  lt  endl   cout  lt  lt   str    lt  lt  st str  lt  lt  endl    This is definitely not the prettiest way to do it but it will work

User · Answer

Use a struct or a class for the return value  Using std  pair may work for now  but    it s inflexible if you decide later you want more info returned   it s not very clear from the function s declaration in the header what is being returned and in what order    Returning a structure with self-documenting member variable names will likely be less bug-prone for anyone using your function  Putting my coworker hat on for a moment  your divide result structure is easy for me  a potential user of your function  to immediately understand after 2 seconds  Messing around with ouput parameters or mysterious pairs and tuples would take more time to read through and may be used incorrectly  And most likely even after using the function a few times I still won t remember the correct order of the arguments

User · Answer

I tend to use out-vals in functions like this  because I stick to the paradigm of a function returning success error codes and I like to keep things uniform

User · Answer

Quick answer   include  lt iostream gt  using namespace std      different values of  operate  can return different number  int yourFunction int a  int b  int operate        a   1      b   2       if  operate   1                return a            else               return b           int main         int a  b       a   yourFunction a  b  1      get return 1     b   yourFunction a  b  2      get return 2      return 0

User · Answer

There is precedent for returning structures in the C  and hence C    standard with the div  ldiv  and  in C99  lldiv  functions from  lt stdlib h gt   or  lt cstdlib gt     The  mix of return value and return parameters  is usually the least clean   Having a function return a status and return data via return parameters is sensible in C  it is less obviously sensible in C   where you could use exceptions to relay failure information instead   If there are more than two return values  then a structure-like mechanism is probably best

User · Answer

Alternatives include arrays  generators  and inversion of control  but none is appropriate here   Some  e g  Microsoft in historical Win32  tend to use reference parameters for simplicity  because it s clear who allocates and how it will look on the stack  reduces the proliferation of structures  and allows a separate return value for success    Pure  programmers prefer the struct  assuming it is the function value  as is the case here   rather than something that s touched incidentally by the function   If you had a more complicated procedure  or something with state  you d probably use references  assuming you have a reason for not using a class

User · Answer

Quick answer   include  lt iostream gt  using namespace std      different values of  operate  can return different number  int yourFunction int a  int b  int operate        a   1      b   2       if  operate   1                return a            else               return b           int main         int a  b       a   yourFunction a  b  1      get return 1     b   yourFunction a  b  2      get return 2      return 0

User · Answer

Boost tuple would be my preferred choice for a generalized system of returning more than one value from a function    Possible example   include  boost tuple tuple hpp   tuple  lt int int gt  divide  int dividend int divisor         return make tuple dividend   divisor dividend   divisor

User · Answer

Alternatives include arrays  generators  and inversion of control  but none is appropriate here   Some  e g  Microsoft in historical Win32  tend to use reference parameters for simplicity  because it s clear who allocates and how it will look on the stack  reduces the proliferation of structures  and allows a separate return value for success    Pure  programmers prefer the struct  assuming it is the function value  as is the case here   rather than something that s touched incidentally by the function   If you had a more complicated procedure  or something with state  you d probably use references  assuming you have a reason for not using a class

User · Answer

I tend to use out-vals in functions like this  because I stick to the paradigm of a function returning success error codes and I like to keep things uniform

User · Answer

I d say there is no preferred method  it all depends on what you re going to do with the response  If the results are going to be used together in further processing then structures make sense  if not I d tend to pass then as individual references unless the function was going to be used in a composite statement   x   divide  x  y  z     divide  a  b  c     I often choose to pass  out structures  by reference in the parameter list rather than having the pass by copy overhead of returning a new structure  but this is sweating the small stuff    void divide int dividend  int divisor  Answer  amp ans    Are out parameters confusing  A parameter sent as reference suggests the value is going to change  as opposed to a const reference   Sensible naming also removes confusion

User · Answer

For returning two values I use a std  pair  usually typedef d    You should look at boost  tuple  in C  11 and newer  there s std  tuple  for more than two return results   With introduction of structured binding in C   17  returning std  tuple should probably become accepted standard

User · Answer

It s entirely dependent upon the actual function and the meaning of the multiple values  and their sizes    If they re related as in your fraction example  then I d go with a struct or class instance  If they re not really related and can t be grouped into a class struct then perhaps you should refactor your method into two  Depending upon the in-memory size of the values you re returning  you may want to return a pointer to a class instance or struct  or use reference parameters

User · Answer

Why do you insist on a function with multiple return values  With OOP you can use a class offering a regular function with a single return value  and any number of additional  return values  like below  The advantage is that the caller has a choice of looking at the extra data members  but is not required to do this  This is the preferred method for complicated data base or networking calls  where lots of additional return info may be needed in case errors occur   To answer your original question  this example has a method to return the quotient  which is what most callers may need  and additionally  after the method call  you can get the remainder as a data member   class div     public        int remainder         int quotient int dividend  int divisor            remainder                 return

User · Answer

It s entirely dependent upon the actual function and the meaning of the multiple values  and their sizes    If they re related as in your fraction example  then I d go with a struct or class instance  If they re not really related and can t be grouped into a class struct then perhaps you should refactor your method into two  Depending upon the in-memory size of the values you re returning  you may want to return a pointer to a class instance or struct  or use reference parameters

User · Answer

The OO solution for this is to create a ratio class   It wouldn t take any extra code  would save some   would be significantly cleaner clearer  and would give you some extra refactorings letting you clean up code outside this class as well   Actually I think someone recommended returning a structure  which is close enough but hides the intent that this needs to be a fully thought-out class with constructor and a few methods  in fact  the  method  that you originally mentioned  as returning the pair  should most likely be a member of this class returning an instance of itself   I know your example was just an  Example   but the fact is that unless your function is doing way more than any function should be doing  if you want it to return multiple values you are almost certainly missing an object   Don t be afraid to create these tiny classes to do little pieces of work--that s the magic of OO--you end up breaking it down until every method is very small and simple and every class small and understandable    Another thing that should have been an indicator that something was wrong  in OO you have essentially no data--OO isn t about passing around data  a class needs to manage and manipulate it s own data internally  any data passing  including accessors  is a sign that you may need to rethink something

User · Answer

Alternatives include arrays  generators  and inversion of control  but none is appropriate here   Some  e g  Microsoft in historical Win32  tend to use reference parameters for simplicity  because it s clear who allocates and how it will look on the stack  reduces the proliferation of structures  and allows a separate return value for success    Pure  programmers prefer the struct  assuming it is the function value  as is the case here   rather than something that s touched incidentally by the function   If you had a more complicated procedure  or something with state  you d probably use references  assuming you have a reason for not using a class

User · Answer

Boost tuple would be my preferred choice for a generalized system of returning more than one value from a function    Possible example   include  boost tuple tuple hpp   tuple  lt int int gt  divide  int dividend int divisor         return make tuple dividend   divisor dividend   divisor

User · Answer

Use a struct or a class for the return value  Using std  pair may work for now  but    it s inflexible if you decide later you want more info returned   it s not very clear from the function s declaration in the header what is being returned and in what order    Returning a structure with self-documenting member variable names will likely be less bug-prone for anyone using your function  Putting my coworker hat on for a moment  your divide result structure is easy for me  a potential user of your function  to immediately understand after 2 seconds  Messing around with ouput parameters or mysterious pairs and tuples would take more time to read through and may be used incorrectly  And most likely even after using the function a few times I still won t remember the correct order of the arguments

User · Answer

Personally  I generally dislike return parameters for a number of reasons    it is not always obvious in the invocation which parameters are ins and which are outs you generally have to create a local variable to catch the result  while return values can be used inline  which may or may not be a good idea  but at least you have the option  it seems cleaner to me to have an  in door  and an  out door  to a function -- all the inputs go in here  all the outputs come out there I like to keep my argument lists as short as possible   I also have some reservations about the pair tuple technique   Mainly  there is often no natural order to the return values   How is the reader of the code to know whether result first is the quotient or the remainder   And the implementer could change the order  which would break existing code   This is especially insidious if the values are the same type so that no compiler error or warning would be generated   Actually  these arguments apply to return parameters as well   Here s another code example  this one a bit less trivial   pair lt double double gt  calculateResultingVelocity double windSpeed  double windAzimuth                                                 double planeAirspeed  double planeCourse    pair lt double double gt  result   calculateResultingVelocity 25  320  280  90   cout  lt  lt  result first  lt  lt  endl  cout  lt  lt  result second  lt  lt  endl    Does this print groundspeed and course  or course and groundspeed   It s not obvious   Compare to this   struct Velocity       double speed      double azimuth     Velocity calculateResultingVelocity double windSpeed  double windAzimuth                                      double planeAirspeed  double planeCourse    Velocity result   calculateResultingVelocity 25  320  280  90   cout  lt  lt  result speed  lt  lt  endl  cout  lt  lt  result azimuth  lt  lt  endl    I think this is clearer   So I think my first choice in general is the struct technique   The pair tuple idea is likely a great solution in certain cases   I d like to avoid the return parameters when possible

User · Answer

rather than returning multiple values just return one of them and make a reference of others in the required function for eg   int divide int a int b int quo int  amp rem

User · Answer

std  pair lt int  int gt  divide int dividend  int divisor               return std  make pair quotient  remainder      std  pair lt int  int gt  answer   divide 5 2       answer first    quotient     answer second    remainder   std  pair is essentially your struct solution  but already defined for you  and ready to adapt to any two data types

User · Answer

There are a bunch of ways to return multiple parameters   I m going to be exhastive  Use reference parameters  void foo  int amp  result  int amp  other result     use pointer parameters  void foo  int  result  int  other result     which has the advantage that you have to do a  amp  at the call-site  possibly alerting people it is an out-parameter  Write a template and use it  template lt class T gt  struct out     std  function lt void T  gt  target    out T  t  target  t  T amp  amp  in   if  t   t   std  move in           out std  optional lt T gt   t  target  t  T amp  amp  in   if  t  t- gt emplace std  move in            out std  aligned storage t lt sizeof T   alignof T  gt   t       target  t  T amp  amp  in     new   void  t   T std  move in             template lt class   Args gt     TODO  SFINAE enable if test   void emplace Args amp  amp    args        target  T std  forward lt Args gt  args               template lt class X gt     TODO  SFINAE enable if test   void operator  X amp  amp x   emplace std  forward lt X gt  x        template lt class   Args gt     TODO  SFINAE enable if test   void operator   Args    amp  amp args   emplace std  forward lt Args gt  args             then we can do  void foo  out lt int gt  result  out lt int gt  other result    and all is good   foo is no longer able to read any value passed in as a bonus  Other ways of defining a spot you can put data can be used to construct out   A callback to emplace things somewhere  for example  We can return a structure  struct foo r   int result  int other result     foo r foo     whick works ok in every version of C    and in c  17 this also permits  auto amp  amp  result  other result  foo     at zero cost   Parameters can even not even be moved thanks to guaranteed elision  We could return a std  tuple  std  tuple lt int  int gt  foo     which has the downside that parameters are not named   This permits the c  17  auto amp  amp  result  other result  foo     as well   Prior to c  17 we can instead do  int result  other result  std  tie result  other result    foo     which is just a bit more awkward   Guaranteed elision doesn t work here  however  Going into stranger territory  and this is after out lt  gt     we can use continuation passing style  void foo  std  function lt void int result  int other result  gt      and now callers do  foo    amp   int result  int other result         code          a benefit of this style is you can return an arbitrary number of values  with uniform type  without having to manage memory  void get all values  std  function lt void int  gt  value    the value callback could be called 500 times when you get all values    amp   int value       For pure insanity  you could even use a continuation on the continuation  void foo  std  function lt void int  std  function lt void int  gt   gt  result     whose use looks like  foo    amp   int result  auto amp  amp  other   other   amp   int other        code            which would permit many-one relationships between result and other  Again with uniforn values  we can do this  void foo  std  function lt  void span lt int gt    gt  results    here  we call the callback with a span of results   We can even do this repeatedly  Using this  you can have a function that efficiently passes megabytes of data without doing any allocation off the stack  void foo  std  function lt  void span lt int gt    gt  results       int local buffer 1024     std  size t used   0    auto send data   amp        if   used  return      results   local buffer  used         used   0         auto add datum   amp   int x       local buffer used    x        used      if  used    1024  send data           auto add data   amp   gsl  span lt int const gt  xs        for  auto x xs  add datum x          for  int i   0  i  lt  7  1 lt  lt 20     i        add datum i         send data       any leftover    Now  std  function is a bit heavy for this  as we would be doing this in zero-overhead no-allocation environments   So we d want a function view that never allocates  Another solution is  std  function lt void std  function lt void int result  int other result  gt   gt  foo int input    where instead of taking the callback and invoking it  foo instead returns a function which takes the callback  foo 7    amp   int result  int other result      code         this breaks the output parameters from the input parameters by having separate brackets  With variant and c  20 coroutines  you could make foo a generator of a variant of the return types  or just the return type    The syntax is not yet fixed  so I won t give examples  In the world of signals and slots  a function that exposes a set of signals  template lt class   Args gt  struct broadcaster   broadcaster lt int  int gt  foo     allows you to create a foo that does work async and broadcasts the result when it is finished  Down this line we have a variety of pipeline techniques  where a function doesn t do something but rather arranges for data to be connected in some way  and the doing is relatively independant  foo  int source    int dest1  int dest2     then this code doesn t do anything until int source has integers to provide it   When it does  int dest1 and int dest2 start recieving the results

User · Answer

We can declare the function such that  it returns a structure type user defined variable or a pointer to it   And by the property of a structure  we know that a structure in C can hold multiple values of asymmetrical types  i e  one int variable  four char variables  two float variables and so on

User · Answer

For returning two values I use a std  pair  usually typedef d    You should look at boost  tuple  in C  11 and newer  there s std  tuple  for more than two return results   With introduction of structured binding in C   17  returning std  tuple should probably become accepted standard

User · Answer

The OO solution for this is to create a ratio class   It wouldn t take any extra code  would save some   would be significantly cleaner clearer  and would give you some extra refactorings letting you clean up code outside this class as well   Actually I think someone recommended returning a structure  which is close enough but hides the intent that this needs to be a fully thought-out class with constructor and a few methods  in fact  the  method  that you originally mentioned  as returning the pair  should most likely be a member of this class returning an instance of itself   I know your example was just an  Example   but the fact is that unless your function is doing way more than any function should be doing  if you want it to return multiple values you are almost certainly missing an object   Don t be afraid to create these tiny classes to do little pieces of work--that s the magic of OO--you end up breaking it down until every method is very small and simple and every class small and understandable    Another thing that should have been an indicator that something was wrong  in OO you have essentially no data--OO isn t about passing around data  a class needs to manage and manipulate it s own data internally  any data passing  including accessors  is a sign that you may need to rethink something

User · Answer

Personally  I generally dislike return parameters for a number of reasons    it is not always obvious in the invocation which parameters are ins and which are outs you generally have to create a local variable to catch the result  while return values can be used inline  which may or may not be a good idea  but at least you have the option  it seems cleaner to me to have an  in door  and an  out door  to a function -- all the inputs go in here  all the outputs come out there I like to keep my argument lists as short as possible   I also have some reservations about the pair tuple technique   Mainly  there is often no natural order to the return values   How is the reader of the code to know whether result first is the quotient or the remainder   And the implementer could change the order  which would break existing code   This is especially insidious if the values are the same type so that no compiler error or warning would be generated   Actually  these arguments apply to return parameters as well   Here s another code example  this one a bit less trivial   pair lt double double gt  calculateResultingVelocity double windSpeed  double windAzimuth                                                 double planeAirspeed  double planeCourse    pair lt double double gt  result   calculateResultingVelocity 25  320  280  90   cout  lt  lt  result first  lt  lt  endl  cout  lt  lt  result second  lt  lt  endl    Does this print groundspeed and course  or course and groundspeed   It s not obvious   Compare to this   struct Velocity       double speed      double azimuth     Velocity calculateResultingVelocity double windSpeed  double windAzimuth                                      double planeAirspeed  double planeCourse    Velocity result   calculateResultingVelocity 25  320  280  90   cout  lt  lt  result speed  lt  lt  endl  cout  lt  lt  result azimuth  lt  lt  endl    I think this is clearer   So I think my first choice in general is the struct technique   The pair tuple idea is likely a great solution in certain cases   I d like to avoid the return parameters when possible

User · Answer

With C  17 you can also return one ore more unmovable uncopyable values  in certain cases   The possibility to return unmovable types come via the new guaranteed return value optimization  and it composes nicely with  aggregates  and what can be called templated constructors   template lt typename T1 typename T2 typename T3 gt  struct many     T1 a    T2 b    T3 c         guide  template lt class T1  class T2  class T3 gt  many T1  T2  T3  - gt  many lt T1  T2  T3 gt    auto f    return many string   5 7  unmovable          int main          in place construct x y z with a string  5 7 and unmovable     auto  x y z    f        The pretty thing about this is that it is guaranteed to not cause any copying or moving  You can make the example many struct variadic too  More details   Returning variadic aggregates  struct  and syntax for C  17 variadic template   39 construction deduction guide  39

User · Answer

We can declare the function such that  it returns a structure type user defined variable or a pointer to it   And by the property of a structure  we know that a structure in C can hold multiple values of asymmetrical types  i e  one int variable  four char variables  two float variables and so on

User · Answer

There are a bunch of ways to return multiple parameters   I m going to be exhastive  Use reference parameters  void foo  int amp  result  int amp  other result     use pointer parameters  void foo  int  result  int  other result     which has the advantage that you have to do a  amp  at the call-site  possibly alerting people it is an out-parameter  Write a template and use it  template lt class T gt  struct out     std  function lt void T  gt  target    out T  t  target  t  T amp  amp  in   if  t   t   std  move in           out std  optional lt T gt   t  target  t  T amp  amp  in   if  t  t- gt emplace std  move in            out std  aligned storage t lt sizeof T   alignof T  gt   t       target  t  T amp  amp  in     new   void  t   T std  move in             template lt class   Args gt     TODO  SFINAE enable if test   void emplace Args amp  amp    args        target  T std  forward lt Args gt  args               template lt class X gt     TODO  SFINAE enable if test   void operator  X amp  amp x   emplace std  forward lt X gt  x        template lt class   Args gt     TODO  SFINAE enable if test   void operator   Args    amp  amp args   emplace std  forward lt Args gt  args             then we can do  void foo  out lt int gt  result  out lt int gt  other result    and all is good   foo is no longer able to read any value passed in as a bonus  Other ways of defining a spot you can put data can be used to construct out   A callback to emplace things somewhere  for example  We can return a structure  struct foo r   int result  int other result     foo r foo     whick works ok in every version of C    and in c  17 this also permits  auto amp  amp  result  other result  foo     at zero cost   Parameters can even not even be moved thanks to guaranteed elision  We could return a std  tuple  std  tuple lt int  int gt  foo     which has the downside that parameters are not named   This permits the c  17  auto amp  amp  result  other result  foo     as well   Prior to c  17 we can instead do  int result  other result  std  tie result  other result    foo     which is just a bit more awkward   Guaranteed elision doesn t work here  however  Going into stranger territory  and this is after out lt  gt     we can use continuation passing style  void foo  std  function lt void int result  int other result  gt      and now callers do  foo    amp   int result  int other result         code          a benefit of this style is you can return an arbitrary number of values  with uniform type  without having to manage memory  void get all values  std  function lt void int  gt  value    the value callback could be called 500 times when you get all values    amp   int value       For pure insanity  you could even use a continuation on the continuation  void foo  std  function lt void int  std  function lt void int  gt   gt  result     whose use looks like  foo    amp   int result  auto amp  amp  other   other   amp   int other        code            which would permit many-one relationships between result and other  Again with uniforn values  we can do this  void foo  std  function lt  void span lt int gt    gt  results    here  we call the callback with a span of results   We can even do this repeatedly  Using this  you can have a function that efficiently passes megabytes of data without doing any allocation off the stack  void foo  std  function lt  void span lt int gt    gt  results       int local buffer 1024     std  size t used   0    auto send data   amp        if   used  return      results   local buffer  used         used   0         auto add datum   amp   int x       local buffer used    x        used      if  used    1024  send data           auto add data   amp   gsl  span lt int const gt  xs        for  auto x xs  add datum x          for  int i   0  i  lt  7  1 lt  lt 20     i        add datum i         send data       any leftover    Now  std  function is a bit heavy for this  as we would be doing this in zero-overhead no-allocation environments   So we d want a function view that never allocates  Another solution is  std  function lt void std  function lt void int result  int other result  gt   gt  foo int input    where instead of taking the callback and invoking it  foo instead returns a function which takes the callback  foo 7    amp   int result  int other result      code         this breaks the output parameters from the input parameters by having separate brackets  With variant and c  20 coroutines  you could make foo a generator of a variant of the return types  or just the return type    The syntax is not yet fixed  so I won t give examples  In the world of signals and slots  a function that exposes a set of signals  template lt class   Args gt  struct broadcaster   broadcaster lt int  int gt  foo     allows you to create a foo that does work async and broadcasts the result when it is finished  Down this line we have a variety of pipeline techniques  where a function doesn t do something but rather arranges for data to be connected in some way  and the doing is relatively independant  foo  int source    int dest1  int dest2     then this code doesn t do anything until int source has integers to provide it   When it does  int dest1 and int dest2 start recieving the results

User · Answer

If your function returns a value via reference  the compiler cannot store it in a register when calling other functions because  theoretically  the first function can save the address of the variable passed to it in a globally accessible variable  and any subsecuently called functions may change it  so the compiler will have  1  save the value from registers back to memory before calling other functions and  2  re-read it when it is needed from the memory again after any of such calls   If you return by reference  optimization of your program will suffer

User · Answer

Personally  I generally dislike return parameters for a number of reasons    it is not always obvious in the invocation which parameters are ins and which are outs you generally have to create a local variable to catch the result  while return values can be used inline  which may or may not be a good idea  but at least you have the option  it seems cleaner to me to have an  in door  and an  out door  to a function -- all the inputs go in here  all the outputs come out there I like to keep my argument lists as short as possible   I also have some reservations about the pair tuple technique   Mainly  there is often no natural order to the return values   How is the reader of the code to know whether result first is the quotient or the remainder   And the implementer could change the order  which would break existing code   This is especially insidious if the values are the same type so that no compiler error or warning would be generated   Actually  these arguments apply to return parameters as well   Here s another code example  this one a bit less trivial   pair lt double double gt  calculateResultingVelocity double windSpeed  double windAzimuth                                                 double planeAirspeed  double planeCourse    pair lt double double gt  result   calculateResultingVelocity 25  320  280  90   cout  lt  lt  result first  lt  lt  endl  cout  lt  lt  result second  lt  lt  endl    Does this print groundspeed and course  or course and groundspeed   It s not obvious   Compare to this   struct Velocity       double speed      double azimuth     Velocity calculateResultingVelocity double windSpeed  double windAzimuth                                      double planeAirspeed  double planeCourse    Velocity result   calculateResultingVelocity 25  320  280  90   cout  lt  lt  result speed  lt  lt  endl  cout  lt  lt  result azimuth  lt  lt  endl    I think this is clearer   So I think my first choice in general is the struct technique   The pair tuple idea is likely a great solution in certain cases   I d like to avoid the return parameters when possible

User · Answer

Boost tuple would be my preferred choice for a generalized system of returning more than one value from a function    Possible example   include  boost tuple tuple hpp   tuple  lt int int gt  divide  int dividend int divisor         return make tuple dividend   divisor dividend   divisor

User · Answer

rather than returning multiple values just return one of them and make a reference of others in the required function for eg   int divide int a int b int quo int  amp rem

User · Answer

Use a struct or a class for the return value  Using std  pair may work for now  but    it s inflexible if you decide later you want more info returned   it s not very clear from the function s declaration in the header what is being returned and in what order    Returning a structure with self-documenting member variable names will likely be less bug-prone for anyone using your function  Putting my coworker hat on for a moment  your divide result structure is easy for me  a potential user of your function  to immediately understand after 2 seconds  Messing around with ouput parameters or mysterious pairs and tuples would take more time to read through and may be used incorrectly  And most likely even after using the function a few times I still won t remember the correct order of the arguments

User · Answer

There is precedent for returning structures in the C  and hence C    standard with the div  ldiv  and  in C99  lldiv  functions from  lt stdlib h gt   or  lt cstdlib gt     The  mix of return value and return parameters  is usually the least clean   Having a function return a status and return data via return parameters is sensible in C  it is less obviously sensible in C   where you could use exceptions to relay failure information instead   If there are more than two return values  then a structure-like mechanism is probably best

User · Answer

For returning two values I use a std  pair  usually typedef d    You should look at boost  tuple  in C  11 and newer  there s std  tuple  for more than two return results   With introduction of structured binding in C   17  returning std  tuple should probably become accepted standard

User · Answer

In C  11 you can    include  lt tuple gt   std  tuple lt int  int gt  divide int dividend  int divisor        return  std  make tuple dividend   divisor  dividend   divisor       include  lt iostream gt   int main         using namespace std       int quotient  remainder       tie quotient  remainder    divide 14  3        cout  lt  lt  quotient  lt  lt       lt  lt  remainder  lt  lt  endl      In C  17    include  lt tuple gt   std  tuple lt int  int gt  divide int dividend  int divisor        return   dividend   divisor  dividend   divisor       include  lt iostream gt   int main         using namespace std       auto  quotient  remainder    divide 14  3        cout  lt  lt  quotient  lt  lt       lt  lt  remainder  lt  lt  endl      or with structs   auto divide int dividend  int divisor        struct result  int quotient  int remainder        return result  dividend   divisor  dividend   divisor       include  lt iostream gt   int main         using namespace std       auto result   divide 14  3        cout  lt  lt  result quotient  lt  lt       lt  lt  result remainder  lt  lt  endl          or      auto  quotient  remainder    divide 14  3        cout  lt  lt  quotient  lt  lt       lt  lt  remainder  lt  lt  endl

User · Answer

The OO solution for this is to create a ratio class   It wouldn t take any extra code  would save some   would be significantly cleaner clearer  and would give you some extra refactorings letting you clean up code outside this class as well   Actually I think someone recommended returning a structure  which is close enough but hides the intent that this needs to be a fully thought-out class with constructor and a few methods  in fact  the  method  that you originally mentioned  as returning the pair  should most likely be a member of this class returning an instance of itself   I know your example was just an  Example   but the fact is that unless your function is doing way more than any function should be doing  if you want it to return multiple values you are almost certainly missing an object   Don t be afraid to create these tiny classes to do little pieces of work--that s the magic of OO--you end up breaking it down until every method is very small and simple and every class small and understandable    Another thing that should have been an indicator that something was wrong  in OO you have essentially no data--OO isn t about passing around data  a class needs to manage and manipulate it s own data internally  any data passing  including accessors  is a sign that you may need to rethink something

User · Answer

There is precedent for returning structures in the C  and hence C    standard with the div  ldiv  and  in C99  lldiv  functions from  lt stdlib h gt   or  lt cstdlib gt     The  mix of return value and return parameters  is usually the least clean   Having a function return a status and return data via return parameters is sensible in C  it is less obviously sensible in C   where you could use exceptions to relay failure information instead   If there are more than two return values  then a structure-like mechanism is probably best

User · Answer

If your function returns a value via reference  the compiler cannot store it in a register when calling other functions because  theoretically  the first function can save the address of the variable passed to it in a globally accessible variable  and any subsecuently called functions may change it  so the compiler will have  1  save the value from registers back to memory before calling other functions and  2  re-read it when it is needed from the memory again after any of such calls   If you return by reference  optimization of your program will suffer

User · Answer

For returning two values I use a std  pair  usually typedef d    You should look at boost  tuple  in C  11 and newer  there s std  tuple  for more than two return results   With introduction of structured binding in C   17  returning std  tuple should probably become accepted standard

User · Answer

I tend to use out-vals in functions like this  because I stick to the paradigm of a function returning success error codes and I like to keep things uniform

User · Answer

Here  i am writing a program that is returning multiple values more than two values  in c    This program is executable in c  14  G  4 9 2   program is like a calculator      include  lt tuple gt    include  lt iostream gt   using namespace std    tuple  lt  int int int int int  gt    cal int n1  int n2        return  make tuple n1 n2 n1 n2 n1 n2 n1-n2 n1 n2      int main         int qut rer add sub mul a b      cin gt  gt a gt  gt b      tie qut rer add sub mul  cal a b       cout  lt  lt   quotient    lt  lt qut lt  lt endl      cout  lt  lt   remainder    lt  lt rer lt  lt endl      cout  lt  lt   addition    lt  lt add lt  lt endl      cout  lt  lt   subtraction    lt  lt sub lt  lt endl      cout  lt  lt   multiplication    lt  lt mul lt  lt endl      return 0      So  you can clearly understand that in this way you can return multiple values from a function  using std  pair only 2 values can be returned while std  tuple can return more than two values

User · Answer

Use a struct or a class for the return value  Using std  pair may work for now  but    it s inflexible if you decide later you want more info returned   it s not very clear from the function s declaration in the header what is being returned and in what order    Returning a structure with self-documenting member variable names will likely be less bug-prone for anyone using your function  Putting my coworker hat on for a moment  your divide result structure is easy for me  a potential user of your function  to immediately understand after 2 seconds  Messing around with ouput parameters or mysterious pairs and tuples would take more time to read through and may be used incorrectly  And most likely even after using the function a few times I still won t remember the correct order of the arguments

User · Answer

The OO solution for this is to create a ratio class   It wouldn t take any extra code  would save some   would be significantly cleaner clearer  and would give you some extra refactorings letting you clean up code outside this class as well   Actually I think someone recommended returning a structure  which is close enough but hides the intent that this needs to be a fully thought-out class with constructor and a few methods  in fact  the  method  that you originally mentioned  as returning the pair  should most likely be a member of this class returning an instance of itself   I know your example was just an  Example   but the fact is that unless your function is doing way more than any function should be doing  if you want it to return multiple values you are almost certainly missing an object   Don t be afraid to create these tiny classes to do little pieces of work--that s the magic of OO--you end up breaking it down until every method is very small and simple and every class small and understandable    Another thing that should have been an indicator that something was wrong  in OO you have essentially no data--OO isn t about passing around data  a class needs to manage and manipulate it s own data internally  any data passing  including accessors  is a sign that you may need to rethink something

User · Answer

Alternatives include arrays  generators  and inversion of control  but none is appropriate here   Some  e g  Microsoft in historical Win32  tend to use reference parameters for simplicity  because it s clear who allocates and how it will look on the stack  reduces the proliferation of structures  and allows a separate return value for success    Pure  programmers prefer the struct  assuming it is the function value  as is the case here   rather than something that s touched incidentally by the function   If you had a more complicated procedure  or something with state  you d probably use references  assuming you have a reason for not using a class

User · Answer

std  pair lt int  int gt  divide int dividend  int divisor               return std  make pair quotient  remainder      std  pair lt int  int gt  answer   divide 5 2       answer first    quotient     answer second    remainder   std  pair is essentially your struct solution  but already defined for you  and ready to adapt to any two data types

User · Answer

I tend to use out-vals in functions like this  because I stick to the paradigm of a function returning success error codes and I like to keep things uniform

User · Answer

I d say there is no preferred method  it all depends on what you re going to do with the response  If the results are going to be used together in further processing then structures make sense  if not I d tend to pass then as individual references unless the function was going to be used in a composite statement   x   divide  x  y  z     divide  a  b  c     I often choose to pass  out structures  by reference in the parameter list rather than having the pass by copy overhead of returning a new structure  but this is sweating the small stuff    void divide int dividend  int divisor  Answer  amp ans    Are out parameters confusing  A parameter sent as reference suggests the value is going to change  as opposed to a const reference   Sensible naming also removes confusion

User · Answer

It s entirely dependent upon the actual function and the meaning of the multiple values  and their sizes    If they re related as in your fraction example  then I d go with a struct or class instance  If they re not really related and can t be grouped into a class struct then perhaps you should refactor your method into two  Depending upon the in-memory size of the values you re returning  you may want to return a pointer to a class instance or struct  or use reference parameters

User · Answer

Boost tuple would be my preferred choice for a generalized system of returning more than one value from a function    Possible example   include  boost tuple tuple hpp   tuple  lt int int gt  divide  int dividend int divisor         return make tuple dividend   divisor dividend   divisor

User · Answer

I d say there is no preferred method  it all depends on what you re going to do with the response  If the results are going to be used together in further processing then structures make sense  if not I d tend to pass then as individual references unless the function was going to be used in a composite statement   x   divide  x  y  z     divide  a  b  c     I often choose to pass  out structures  by reference in the parameter list rather than having the pass by copy overhead of returning a new structure  but this is sweating the small stuff    void divide int dividend  int divisor  Answer  amp ans    Are out parameters confusing  A parameter sent as reference suggests the value is going to change  as opposed to a const reference   Sensible naming also removes confusion

User · Answer

Here  i am writing a program that is returning multiple values more than two values  in c    This program is executable in c  14  G  4 9 2   program is like a calculator      include  lt tuple gt    include  lt iostream gt   using namespace std    tuple  lt  int int int int int  gt    cal int n1  int n2        return  make tuple n1 n2 n1 n2 n1 n2 n1-n2 n1 n2      int main         int qut rer add sub mul a b      cin gt  gt a gt  gt b      tie qut rer add sub mul  cal a b       cout  lt  lt   quotient    lt  lt qut lt  lt endl      cout  lt  lt   remainder    lt  lt rer lt  lt endl      cout  lt  lt   addition    lt  lt add lt  lt endl      cout  lt  lt   subtraction    lt  lt sub lt  lt endl      cout  lt  lt   multiplication    lt  lt mul lt  lt endl      return 0      So  you can clearly understand that in this way you can return multiple values from a function  using std  pair only 2 values can be returned while std  tuple can return more than two values

User · Answer

It s entirely dependent upon the actual function and the meaning of the multiple values  and their sizes    If they re related as in your fraction example  then I d go with a struct or class instance  If they re not really related and can t be grouped into a class struct then perhaps you should refactor your method into two  Depending upon the in-memory size of the values you re returning  you may want to return a pointer to a class instance or struct  or use reference parameters

User · Answer

std  pair lt int  int gt  divide int dividend  int divisor               return std  make pair quotient  remainder      std  pair lt int  int gt  answer   divide 5 2       answer first    quotient     answer second    remainder   std  pair is essentially your struct solution  but already defined for you  and ready to adapt to any two data types

User · Answer

There is precedent for returning structures in the C  and hence C    standard with the div  ldiv  and  in C99  lldiv  functions from  lt stdlib h gt   or  lt cstdlib gt     The  mix of return value and return parameters  is usually the least clean   Having a function return a status and return data via return parameters is sensible in C  it is less obviously sensible in C   where you could use exceptions to relay failure information instead   If there are more than two return values  then a structure-like mechanism is probably best

User · Answer

If your function returns a value via reference  the compiler cannot store it in a register when calling other functions because  theoretically  the first function can save the address of the variable passed to it in a globally accessible variable  and any subsecuently called functions may change it  so the compiler will have  1  save the value from registers back to memory before calling other functions and  2  re-read it when it is needed from the memory again after any of such calls   If you return by reference  optimization of your program will suffer

User · Answer

Why do you insist on a function with multiple return values  With OOP you can use a class offering a regular function with a single return value  and any number of additional  return values  like below  The advantage is that the caller has a choice of looking at the extra data members  but is not required to do this  This is the preferred method for complicated data base or networking calls  where lots of additional return info may be needed in case errors occur   To answer your original question  this example has a method to return the quotient  which is what most callers may need  and additionally  after the method call  you can get the remainder as a data member   class div     public        int remainder         int quotient int dividend  int divisor            remainder                 return

User · Answer

I would just do it by reference if it s only a few return values but for more complex types you can also just do it like this     static struct SomeReturnType  int a b c  string str   SomeFunction       return  1 2 3 string  hello world        make sure you return values in the right order      use  static  to limit the scope of the return type to this compilation unit if it s only meant to be a temporary return type     SomeReturnType st   SomeFunction     cout  lt  lt   a      lt  lt  st a  lt  lt  endl   cout  lt  lt   b      lt  lt  st b  lt  lt  endl   cout  lt  lt   c      lt  lt  st c  lt  lt  endl   cout  lt  lt   str    lt  lt  st str  lt  lt  endl    This is definitely not the prettiest way to do it but it will work

User · Answer

I d say there is no preferred method  it all depends on what you re going to do with the response  If the results are going to be used together in further processing then structures make sense  if not I d tend to pass then as individual references unless the function was going to be used in a composite statement   x   divide  x  y  z     divide  a  b  c     I often choose to pass  out structures  by reference in the parameter list rather than having the pass by copy overhead of returning a new structure  but this is sweating the small stuff    void divide int dividend  int divisor  Answer  amp ans    Are out parameters confusing  A parameter sent as reference suggests the value is going to change  as opposed to a const reference   Sensible naming also removes confusion

User · Answer

In C  11 you can    include  lt tuple gt   std  tuple lt int  int gt  divide int dividend  int divisor        return  std  make tuple dividend   divisor  dividend   divisor       include  lt iostream gt   int main         using namespace std       int quotient  remainder       tie quotient  remainder    divide 14  3        cout  lt  lt  quotient  lt  lt       lt  lt  remainder  lt  lt  endl      In C  17    include  lt tuple gt   std  tuple lt int  int gt  divide int dividend  int divisor        return   dividend   divisor  dividend   divisor       include  lt iostream gt   int main         using namespace std       auto  quotient  remainder    divide 14  3        cout  lt  lt  quotient  lt  lt       lt  lt  remainder  lt  lt  endl      or with structs   auto divide int dividend  int divisor        struct result  int quotient  int remainder        return result  dividend   divisor  dividend   divisor       include  lt iostream gt   int main         using namespace std       auto result   divide 14  3        cout  lt  lt  result quotient  lt  lt       lt  lt  result remainder  lt  lt  endl          or      auto  quotient  remainder    divide 14  3        cout  lt  lt  quotient  lt  lt       lt  lt  remainder  lt  lt  endl

User · Answer

If your function returns a value via reference  the compiler cannot store it in a register when calling other functions because  theoretically  the first function can save the address of the variable passed to it in a globally accessible variable  and any subsecuently called functions may change it  so the compiler will have  1  save the value from registers back to memory before calling other functions and  2  re-read it when it is needed from the memory again after any of such calls   If you return by reference  optimization of your program will suffer

User · Answer

With C  17 you can also return one ore more unmovable uncopyable values  in certain cases   The possibility to return unmovable types come via the new guaranteed return value optimization  and it composes nicely with  aggregates  and what can be called templated constructors   template lt typename T1 typename T2 typename T3 gt  struct many     T1 a    T2 b    T3 c         guide  template lt class T1  class T2  class T3 gt  many T1  T2  T3  - gt  many lt T1  T2  T3 gt    auto f    return many string   5 7  unmovable          int main          in place construct x y z with a string  5 7 and unmovable     auto  x y z    f        The pretty thing about this is that it is guaranteed to not cause any copying or moving  You can make the example many struct variadic too  More details   Returning variadic aggregates  struct  and syntax for C  17 variadic template   39 construction deduction guide  39

User · Answer

std  pair lt int  int gt  divide int dividend  int divisor               return std  make pair quotient  remainder      std  pair lt int  int gt  answer   divide 5 2       answer first    quotient     answer second    remainder   std  pair is essentially your struct solution  but already defined for you  and ready to adapt to any two data types

User · Answer

Personally  I generally dislike return parameters for a number of reasons    it is not always obvious in the invocation which parameters are ins and which are outs you generally have to create a local variable to catch the result  while return values can be used inline  which may or may not be a good idea  but at least you have the option  it seems cleaner to me to have an  in door  and an  out door  to a function -- all the inputs go in here  all the outputs come out there I like to keep my argument lists as short as possible   I also have some reservations about the pair tuple technique   Mainly  there is often no natural order to the return values   How is the reader of the code to know whether result first is the quotient or the remainder   And the implementer could change the order  which would break existing code   This is especially insidious if the values are the same type so that no compiler error or warning would be generated   Actually  these arguments apply to return parameters as well   Here s another code example  this one a bit less trivial   pair lt double double gt  calculateResultingVelocity double windSpeed  double windAzimuth                                                 double planeAirspeed  double planeCourse    pair lt double double gt  result   calculateResultingVelocity 25  320  280  90   cout  lt  lt  result first  lt  lt  endl  cout  lt  lt  result second  lt  lt  endl    Does this print groundspeed and course  or course and groundspeed   It s not obvious   Compare to this   struct Velocity       double speed      double azimuth     Velocity calculateResultingVelocity double windSpeed  double windAzimuth                                      double planeAirspeed  double planeCourse    Velocity result   calculateResultingVelocity 25  320  280  90   cout  lt  lt  result speed  lt  lt  endl  cout  lt  lt  result azimuth  lt  lt  endl    I think this is clearer   So I think my first choice in general is the struct technique   The pair tuple idea is likely a great solution in certain cases   I d like to avoid the return parameters when possible

[c++] Returning multiple values from a C++ function

Examples related to c++