std::tuple<int,string,int*>   MyFunc()
{
   int res1 = 5;
   string res2 = “ssssss”;
   int* res3 = (int*)malloc…;

   return {res1,res2,res3};
}
...

auto tuple = MyFunc(); // так можно
auto [some_it, some_string, some_pointer] = MyFunc(); // так тоже можно начиная с ++17

fn FyMunc() -> (i32, String, &'static i32) {
    let res1 = 5;
    let res2 = "ssssss";
    let res3 = &glob;
    return (res1, res2, res3);
}

>>> def f(): return 1,2,3
...
>>> def g(a,b,c): print(a,b,c)
...
>>> g(*f())
1 2 3

using System;
public class Test
{
    static fn() : int*string*double
        { (1, "one", 1.0) }
        
    static getName(key : int, name : string, len : double) : string
        { name }
    
    static Main () : void
    {
        Console.WriteLine (getName(fn()));
    }
}

def MyFunc(): (Int, String, Array[Int]) = 
  val res1 = 5
  val res2 = "ssssss"
  val res3 = Array[Int]()

  (res1, res2, res3)

printn(MyFunc()._2)
val b = MyFunc()._1

val (i, s, arr) = MyFunc()

func foo() (int, int, int) {
    return 1, 2, 3
}

- - -

a, b, c = foo()

a, b = b, a

(int, string, int*) MyFunc()
{
   return (5, "ssssss", malloc(...));
}

var (x, y, z) = MyFunc();

func minmax(nums []int) (min, max int) {
        if len(nums) > 0 {
                min = nums[0]
                max = nums[0]
                for i := 1; i < len(nums); i++ {
                        n := nums[i]
                        if n < min {
                                min = n
                        }
                        if n > max {
                                max = n
                        }
                }
        }

        return min, max
}

int/string/int*   MyFunc()
{
   int res1 = 5;
   string res2 = “ssssss”;
   int* res3 = (int*)malloc…;

   return1 res1;
   return2 res2;
   return3 res3;
}

Print(MyFunc()2);

int b = MyFunc()1 + 6;

int/string/int*   MyFunc()
{
   int res1 = 5;
   string res2 = “ssssss”;
   int* res3 = (int*)malloc…;

   return1 res1;
   return2 res2;
   return3 res3;
}
Print(MyFunc()2);
int b = MyFunc()1 + 6;

#include <stdio.h>

struct xxx
{
    int a;
    int b;
};

struct xxx func()
{
    struct xxx rrr;
    rrr.a = 33;
    rrr.b = 23;
    return rrr;
}

int main()
{
    struct xxx yyy = func();
    printf("%d, %d", yyy.a, yyy.b);
    return 0;
}

33, 23

int res1, string res2, int* res3 MyFunc()
{
   int res1 = 5;
   string res2 = “ssssss”;
   int* res3 = (int*)malloc…;

   return res1, res2, res3;
}

type
  TMyFuncResult = record
    v1 : Integer;
    v2 : string;
    v3 : Double;
  end;
  
function MyFunc : TMyFuncResult;
begin
  Result.v1 := 1;
  Result.v2 := '1';
  Result.v3 := 1.0;
end;

WriteLn(MyFunc.v2);

int/string/int*   MyFunc()
{
   int res1 = 5;
   string res2 = “ssssss”;
   int* res3 = (int*)malloc…;

   return1 res1;
   return2 res2;
   return3 res3;
}

Print(MyFunc()2);

int b = MyFunc()1 + 6;

struct MyFunc {
    static int fn1() { return 5; }
    static string fn2() { return "ssssss"; }
    static int* fn3() { return (int*)malloc…; }
};

Print(MyFunc::fn2());

int b = MyFunc::fn1() + 6;

int/string/int*   MyFunc()
{
   int res1 = 5;
   int* res3 = (int*)malloc…;

   return1 res1;
   if (res1 == 0)
     return2 "foo"
   else
     return2 "bar";

   for (int i =0; i< 42; i++)
      return3 res3++;
}

int/int find(int[] array, int length, int value)
{ 
   for(int i=0; i<length; i++)
     if (array[i] == value)
     {
       return1 i;
       return2 value;
     }
   return1 -1;
   return2 0;
}

H>int/string/int*   MyFunc()
H>{
H>   int res1 = 5;
H>   string res2 = “ssssss”;
H>   int* res3 = (int*)malloc…;
H>   return1 res1;
H>   return2 res2;
H>   return3 res3;
H>}

H>Print(MyFunc()2);
H>int b = MyFunc()1 + 6;
H>

struct Eklmn { int x; char *y; float z; } my_func(...)
{
    ...
    if (...)
        return (struct Eklmn){.x = 100500};
    if (...)
        return (struct Eklmn){.y = "xaxaxa");
    ...
}

...
printf("%s", my_func(...).y);
int b = my_func(...).x + 6);
...

struct NedoVariant
{
    enum {
    VariantInt, VariantString, VariantFloat...
    } type;

    union {
        int x;
        const char *y;
        float z;
        ...
    };
};