funkcja - wyciaganie wyniku do progarmu glownego

Hej;
Napisalem funkcje do programu. Chce z niejwyciagnac dwa wyniki: int liczba1 oraz int liczba2. Niestety programm glowny dostaje tylko liczbe2.
Czy ktos mi moze doradzic i wskazac prawidlowy zapis ( sadze ze chodzi o skladnie komendy return):

#include <iostream>
#include <sstream>
#include <string>
#include <cstdio>

using namespace std;

string znak;

int konwersja (string znak)
 {
     string kanz;
     int liczba1, liczba2;

      for(int z = znak.size()-1; z >= 0; z--)

            {
                kanz+=znak[z];
            }

            string str = znak;

            sscanf(str.c_str(), "%d", &liczba1);
            str = kanz;

            sscanf(str.c_str(), "%d", &liczba2);
            return (liczba1, liczba2);

 }

int main()
{
  
    cout<<" podaj liczbe: "<<endl;
    cin>>znak;
    cout<<"odwrocenie: "<<konwersja(znak)<<endl;
 
    cout<<"odwrocenie: "<<konwersja(znak)<<endl;


    return 0;
} 

jak myślisz co oznacza w tej linijce:
int konwersja (string znak) te pierwsze 3 literki?

Oznaczają, że ta funkcja zwraca inta. Jednego inta. Nie zwróci dwóch.. Za to moze zwrócic obiekt klasy albo strukturę skladającą się z dwóch lub więcej intów.

std::tuple

tj.

auto konwersja(...)...{
    return make_tuple(liczba1, liczba2);
}

...
int liczba1, liczba2;
tie(liczba1, liczba2) = konwersja();
cout << ...;

Funkcja w C i C++ zwraca tylko jedną wartość! Może to być np struktura/klasa i wtedy będzie można zwrócić 2 liczby

 
struct liczby
{
    int liczba1;
    int liczba2;
};

struct liczby konwersja (string znak)
{
...
}

albo możesz zwracać wartości przez referencje

 
std::bool konwersja (string znak, int &liczba1, int &liczba2)

ale tu widzę pewne "a fuj":

 sscanf(str.c_str(), "%d", &liczba1);

zaprzęganie sscanfa do przeczytania wartości liczby - to jak z armaty do komara...

Dziwne te Wasze rozwiązania. Moja wersja:

using System;
using System.Linq;
using System.Collections.Generic;

namespace Program {
    public interface IValueConverter<T, R> {
        R Convert(T input);
    }

    public class StringToIntValueConverter : IValueConverter<string, int> {
        public int Convert(string input) {
            return int.Parse(input);
        }
    }

    public interface ISupplier<T> {
        T Get { get; }
    }

    public class EndoPairSupplier<T> : ISupplier<Tuple<T, T>> {
        public EndoPairSupplier(T first, T second) {
            _first = first;
            _second = second;
        }

        public Tuple<T, T> Get {
            get { return Tuple.Create(_first, _second); }
        }

        public EndoPairSupplier<R> Each<R>(Func<T, R> fun) {
            return new EndoPairSupplier<R>(fun(_first), fun(_second));
        }

        private readonly T _first;
        private readonly T _second;
    }

    public interface IReverseStrategy<T> {
        T Reverse(T input);
    }

    public class SimpleStringReverseStrategy : IReverseStrategy<string> {
        public string Reverse(string input) {
            var charArray = input.ToCharArray();
            Array.Reverse(charArray);
            return new String(charArray);
        }
    }

    public interface IPairsGenerator<T, T1, T2> {
        IEnumerable<ISupplier<Tuple<T1, T2>>> Generate(params T[] input);
    }

    public class PairsGenerator<T, R> : IPairsGenerator<T, R, R> {
        public PairsGenerator(IReverseStrategy<T> reverser, IValueConverter<T, R> converter) {
            _reverser = reverser;
            _converter = converter;
        }

        public IEnumerable<ISupplier<Tuple<R, R>>> Generate(params T[] input) {
            foreach(var value in input) {
                var reversedValue = _reverser.Reverse(value);
                var pairSupplier = new EndoPairSupplier<T>(value, reversedValue);
                yield return pairSupplier.Each(v => _converter.Convert(v));
            }
        }

        private readonly IReverseStrategy<T> _reverser;
        private readonly IValueConverter<T, R> _converter;
    }

    public class MainClass {
        public static ISupplier<Tuple<int, int>> MyFunc(string numStr) {
            var pairsGenerator = new PairsGenerator<string, int>(
                new SimpleStringReverseStrategy(),
                new StringToIntValueConverter()
            );
            var result = pairsGenerator.Generate(numStr);
            return result.FirstOrDefault();
        }

        public static void Main(string[] args) {
            var numStr = "123";
            var supplier = MyFunc(numStr);
            Console.WriteLine(supplier.Get);
        }
    }
}

[Inny język, ale wszystkie konstrukcje występują w jakiś sposób w C++].

Po kiego grzyba robić z tego jedną funkcję?
Masz dwie niezależne wartości, więc o wiele prościej zrobić dwie osobne funkcje. Na dodatek jak używasz STL to najlepiej robić to na całego.
Wersja C++11

#include <iostream>
using namespace std;

int reversedInt(const string &s) {
    return stoi(string(s.rbegin(), s.rend()));
}

int main() {
	string s;

	while(cin >> s) {
		cout << "Normal=" << stoi(s) << endl;
		cout << "Reversed=" << reversedInt(s) << endl;
	}
	return 0;
}

http://ideone.com/isqKSu
I wersja bez C++11: http://ideone.com/4DSZWH

kaczus napisał:

ale tu widzę pewne "a fuj":

 sscanf(str.c_str(), "%d", &liczba1);

zaprzęganie sscanfa do przeczytania wartości liczby - to jak z armaty do komara...</quote>

zaprzęganie sscanfa do przeczytania wartości liczby - to jak z armaty do komara...

@kaczus co masz na mysli piszac o komarach i armatach?:)
Pytam bo jestem zupelnie zielony. Sam sie ucze, czytajac rozne fora. Zapewne masz racje, ale prosze o jakas podpowiedz, dlaczego tak nie powinno sie robic? Jak Ty byś to napisał?
Dzieki za cierpliwość:)

@polsky77 sscanf jest funkcją "uniwersalną", od zamiany stringa na inta masz atoi i strtol które są wywoływane w sscanf. strtol jest wywolywana w atoi, więc chyba najlepiej użyć jej - jeśli chcesz korzystać z biblioteki standardowej.