某一类型的实例是“一个值”。 请考虑此类:

struct foo {
     int bar;
     double moo;
};

现在我可以编写一个函数，返回该类型的一个值:

foo asdf() { 
    foo result;
    result.bar = 42;
    result.moo = 3.14159;
    return result;
}

PS:不要使用指针。 可以使用所谓的out-parameters，但如果使用，则应该使用引用而不是指针:

void asdf2(int& bar,int& moo) {
     bar = 42;
     moo = 3.14159;
}

像这样呼叫:

int x = 0;
double y = 0.;
asdf2(x,y);

但是，out参数不是很好，因为在foo f=asdf()；中，与asdf2(x，y)相比，函数返回的内容更明显。

您在某处读到的想法是，调用函数，创建对象，将指向对象的指针作为函数的参数传递给对象的代码，而函数通过指针间接分配给对象。

但是，如果要这样做，您应该倾向于使用引用而不是指针，这样就不必处理有人向函数传递null的可能性。

在大多数情况下，最好的方法是返回类的实例。 即使您只能返回一个对象，一个类也可以有多个子对象。 例如，如果您想将两个坐标返回到欧几里得空间中，您可以这样做:

struct Point {
    double x;
    double y;
};

Point example()
{
    // until C++20
    return {
        42.,
        1337.,
    };
    // since C++20
    return {
        .x = 42.,
        .y = 1337.,
    };
}

在这里，我们在一个对象中返回了两个值。

至少有三种途径。

如您已经提到的，第一种方法是使用指针类型的参数返回一个值。

例如

#include <iostream>

int minmax( int x, int y, int *max )
{
    int min = x;
    *max = y;

    if ( y < x )
    {
        min = y;
        *max = x;
    }

    return min; 
}

int main() 
{
    int min, max;

    min = minmax( 20, 10, &max );

    std::cout << "min = " << min << ", max = " << max << '\n';
}

程序输出为

min = 10, max = 20

这里，在程序中，变量max是以C的术语通过引用传递的。

第二种方法是在C++术语中通过引用传递。 例如

#include <iostream>

int minmax( int x, int y, int &max )
{
    int min = x;
    max = y;

    if ( y < x )
    {
        min = y;
        max = x;
    }

    return min; 
}

int main() 
{
    int min, max;

    min = minmax( 20, 10, max );

    std::cout << "min = " << min << ", max = " << max << '\n';
}

程序输出与上图相同。

并且您确实可以返回一个对象，但该对象属于包含其他子对象的复合类型。 例如

#include <iostream>
#include <utility>

std::pair<int, int> minmax( int x, int y )
{
    return y < x ? std::pair<int, int>( y, x ) : std::pair<int, int>( x, y );
}

int main() 
{
    auto p = minmax( 20, 10 );

    std::cout << "min = " << p.first << ", max = " << p.second << '\n';
}

程序输出也与第一个演示程序相同。

如果要返回两个以上的对象，可以使用类模板std::tuple，而不是具有两个数据成员的标准类模板std::pair。 或者可以将自己的复合类型（模板或不模板）编写为结构或类。

例如

#include <iostream>
#include <tuple>

std::tuple<int, int, int> get_sorted( int x, int y, int z )
{
    if ( not ( y < x ) && not ( z < x ) )
    {
        return not ( z < y ) ? std::make_tuple( x, y, z )
                             : std::make_tuple( x, z, y );
    }
    else if ( not ( z < y ) )
    {
        return not ( z < x ) ? std::make_tuple( y, x, z )
                             : std::make_tuple( y, z, x );
    }
    else
    {
        return not ( y < x ) ? std::make_tuple( z, x, y )
                             : std::make_tuple( z, y, x );
    }
}

int main() 
{
    auto t = get_sorted( 15, 10, 20 );

    std::cout << "( " << std::get<0>( t ) 
              << ", " << std::get<1>( t )
              << ", " << std::get<2>( t )
              << " )\n";
}

程序输出为

( 10, 15, 20 )