Как вернуть два вектора из одной функции C ++ [duplicate]

std::pair<int, int> divide(int dividend, int divisor)
{
   // :
   return std::make_pair(quotient, remainder);
}

std::pair<int, int> answer = divide(5,2);
 // answer.first == quotient
 // answer.second == remainder

std :: pair - это, по сути, ваше структурное решение, но уже определенное для вас и готовое к адаптации к любым двум типам данных.

Я склонен использовать out-vals в таких функциях, потому что я придерживаюсь парадигмы функции, возвращающей коды успеха / ошибки, и мне нравится сохранять вещи одинаковыми.

Существует прецедент для возврата структур в стандарте C (и, следовательно, C ++) с функциями div, ldiv (и в C99, lldiv) из <stdlib.h> (или <cstdlib>).

«Смешение возвращаемого значения и возвращаемых параметров» обычно является наименее чистым.

Наличие функции возвращает статус и возвращает данные через возвращаемые параметры в C; это менее очевидно в C ++, где вы могли бы использовать исключения для ретрансляции информации об отказах.

Если имеется более двух возвращаемых значений, то, вероятно, лучше всего подходит структура-подобный механизм.

Здесь я пишу программу, которая возвращает несколько значений (более двух значений) в c ++. Эта программа является исполняемой в c ++ 14 (G ++ 4.9.2). Программа похожа на калькулятор.

#  include <tuple>
# include <iostream>

using namespace std; 

tuple < int,int,int,int,int >   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>>a>>b;
    tie(qut,rer,add,sub,mul)=cal(a,b);
    cout << "quotient= "<<qut<<endl;
    cout << "remainder= "<<rer<<endl;
    cout << "addition= "<<add<<endl;
    cout << "subtraction= "<<sub<<endl;
    cout << "multiplication= "<<mul<<endl;
    return 0;
}

Итак, вы можете четко понимать, что таким образом вы можете вернуть несколько значений из функции. используя std :: pair, могут возвращаться только 2 значения, а std :: tuple может возвращать более двух значений.

вместо того, чтобы возвращать несколько значений, просто верните один из них и сделайте ссылку других в требуемой функции, например:

int divide(int a,int b,int quo,int &rem)

Альтернативы включают в себя массивы, генераторы и инверсию управления , но здесь не подходит.

Некоторые (например, Microsoft в историческом Win32) имеют тенденцию использовать ссылочные параметры для простоты, потому что ясно, кто распределяет и как он будет выглядеть в стеке, уменьшает распространение структур и позволяет получить отдельное возвращаемое значение для успеха.

«Чистые» программисты предпочитают структуру , предполагая, что - значение функции (как это имеет место здесь), а не то, что коснулось функции. Если у вас была более сложная процедура или что-то с состоянием, вы, вероятно, использовали бы ссылки (при условии, что у вас есть причина не использовать класс).

Я бы сказал, что нет предпочтительного метода, все зависит от того, что вы собираетесь делать с ответом. Если результаты будут использоваться вместе в дальнейшей обработке, тогда структуры имеют смысл, если бы я не стал передавать их в качестве отдельных ссылок, если бы функция не использовалась в составном заявлении:

x = divide( x, y, z ) + divide( a, b, c );

Я часто предпочитаю передавать «внешние структуры» по ссылке в списке параметров, вместо того, чтобы иметь пропуск накладных расходов на копирование новой структуры (но это потение малым материалом).

void divide(int dividend, int divisor, Answer &ans)

Изменились ли параметры? Параметр, отправленный как ссылка, указывает на то, что значение изменится (в отличие от ссылки на константу). Разумное именование также устраняет путаницу.

В C ++ 11 вы можете:

#include <tuple>

std::tuple<int, int> divide(int dividend, int divisor) {
    return  std::make_tuple(dividend / divisor, dividend % divisor);
}

#include <iostream>

int main() {
    using namespace std;

    int quotient, remainder;

    tie(quotient, remainder) = divide(14, 3);

    cout << quotient << ',' << remainder << endl;
}

В C ++ 17:

#include <tuple>

std::tuple<int, int> divide(int dividend, int divisor) {
    return  {dividend / divisor, dividend % divisor};
}

#include <iostream>

int main() {
    using namespace std;

    auto [quotient, remainder] = divide(14, 3);

    cout << quotient << ',' << remainder << endl;
}

или с помощью структур:

#include <tuple>

auto divide(int dividend, int divisor) {
    struct result {int quotient; int remainder;};
    return result {dividend / divisor, dividend % divisor};
}

#include <iostream>

int main() {
    using namespace std;

    auto result = divide(14, 3);

    cout << result.quotient << ',' << result.remainder << endl;

    // or

    auto [quotient, remainder] = divide(14, 3);

    cout << quotient << ',' << remainder << endl;
}

Boost tuple был бы моим предпочтительным выбором для обобщенной системы возврата более одного значения из функции.

Возможный пример:

include "boost/tuple/tuple.hpp"

tuple <int,int> divide( int dividend,int divisor ) 

{
  return make_tuple(dividend / divisor,dividend % divisor )
}

Мы можем объявить такую ​​функцию, чтобы она возвращала определенную пользователем структуру типа или указатель на нее. И по свойству структуры мы знаем, что структура в C может содержать несколько значений асимметричных типов (т. Е. Одна переменная int, четыре переменные char, две переменные float и т. Д.)

Почему вы настаиваете на функции с несколькими возвращаемыми значениями? С помощью OOP вы можете использовать класс, предлагающий регулярную функцию с единственным возвращаемым значением, и любое количество дополнительных «возвращаемых значений», как показано ниже. Преимущество заключается в том, что у вызывающего есть возможность взглянуть на дополнительные элементы данных, но это не требуется для этого. Это предпочтительный метод для сложной базы данных или сетевых вызовов, где может потребоваться много дополнительной информации о возврате в случае возникновения ошибок.

Чтобы ответить на ваш исходный вопрос, в этом примере есть метод возврата частного, это то, что может понадобиться большинству абонентов, и, кроме того, после вызова метода вы можете получить остаток в качестве элемента данных.

class div{
   public:
      int remainder;

      int quotient(int dividend, int divisor){
         remainder = ...;
         return ...;
      }
};

Это полностью зависит от фактической функции и значения нескольких значений и их размеров:

• Если они связаны как в примере с вашей долей, то я бы пошел с struct или class instance.
• Если они не связаны друг с другом и не могут быть сгруппированы в класс / struct, возможно, вам необходимо реорганизовать ваш метод на два.
• В зависимости от размер памяти в значениях, которые вы возвращаете, вы можете захотеть вернуть указатель на экземпляр класса или структуру или использовать ссылочные параметры.