3. Mehrere Werte wie zurückgeben ?

Mehrere Werte wie zurückgeben ?

  • Z

    Das macht man mit einer call by reference

    z.b.:

    void swap(void*_ptr_1 , int & k)
{
int iNt=0;

iNt=*((int*)(_ptr_1));
memcpy(_ptr_1,(void*)&k,sizeof(int));
k=iNt;
}

int _tmain(int argc, _TCHAR* argv[])
{
int a=1;
int b=2;
swap((void*)&a,b);

__debugbreak();

	return 0;
}

    grüße

    0
  • U

    zu deiner eigentlichen frage: das kann man über referenzen oder (genutzt, wenn die parameter optional sind) mit pointern.

    fangen wir doch noch einmal von vorn an:

    der einfach halber mal schritt für schritt.
    und da du sicherlich die standard-lib(abgesehen von ein- und ausgabe) nicht nutzen darfst auch ohne diese:

    int quersumme(int value)
{
  int ret_val = 0;
  /* ... */
  return ret_val;
}

    float durchschnitt(int* first, int size)
{
  float sum = 0;
  /* ... */;
  return sum/static_cast<float>(size); //zu static_cast bemühst du mal google
}

    int to_int(const char* str)
{
  int ret_val = 0;
  /* ... */
  return ret_val;
}

    #include <iostream>

//gibt der die länge eines arrays aus, dessen länge zur compilezeit fest steht.
//musst du nciht verstehen, du kannst auch konstante zahlen nehmen.
template <typename T, int S>
int arraylaenge(T (&)[S])
{
  return S;
}

int main()
{
  { /* 1. */
    const char* number_string = "1234";

    int number = to_int(number_string);
    std::cout << quersumme(number) << std::endl;
  }

  { /* 2. */
    numbers[] = { 3, 2, 5, 6, 1, 9 };
    std::cout << durchschnitt( numbers, arraylaenge(numbers) ) << std::endl;
  }
}

    jetzt bauen wir noch die funktionen:

    int quersumme(int value)
{
  int ret_val = 0;
  while(value > 0)
  {
    int letzte_stelle = value%10;
    int value_minus_letzte_stelle = value/10;

    value = value_minus_letzte_stelle;

    ret_val += letzte_stelle;
  }
  return ret_val;
}

    oder kürzer:

    int quersumme(int value)
{
  int ret_val = 0;
  while(value > 0)
  {
    ret_val += value%10;
    value /= 10;
  }
  return ret_val;
}

    und

    float durchschnitt(int* first, int size)
{
  float sum = 0;

  for(int i = 0; i != size; i++)
  {
    sum += static_cast<float> (*first);
    int* next = first+1;
    first = next;
  }

  return sum/static_cast<float>(size);
}

    oder kürzer:

    float durchschnitt(int* first, int size)
{
  float sum = 0;

  for(int i = 0; i != size; ++i, ++first)
  {
    sum += static_cast<float> (*first);
  }

  return sum/static_cast<float>(size);
}

    bleibt nur noch:

    int to_int(const char* str)
{
  int ret_val = 0;

  while(*str != '\0') //strings werden mit einem '\0' terminiert -> wir hätten das ende erreicht
  {
    ret_val = ret_val * 10; //es kommt noch eine stelle -> eine null mehr an die zahl und dann die letzte ziffer einlesen:
    //ggf. überprüfung, ob *str eine ziffer ist
    ret_val += *str-'0';

    ++str; //pointer auf das nächste zeichen vorrücken
  }
  return ret_val;
}

    kürzer:

    int to_int(const char* str)
{
  int ret_val = 0;

  while(*str != '\0')
  {
    ret_val *= 10;
    ret_val += *str-'0';

    ++str;
  }
  return ret_val;
}

    an manchen stellen gibt es bessere typen(längenangaben mit signed werten etc., aber das soll erst mal nicht stören)
    mit der standard-lib kann man vieles einfacher, eleganter, lesbarer usw. machen. vor allem aber auch sicherer. bei uns gibt es keine einzige abfrage, ob die zahl/das zeichen/... das ist, was wir erwarten. das müsstest du selbst noch ergänzen.

    bb

    edit: @zeusosc: genau. das sollte seine frage beantworten. immerhin hast du ja daran gedacht, dass er ein anfänger ist und leicht verständlichen quellcode ohne irgendwelchen zusätzlichen schnick-schnack gepostet 👍

    0
  • U

    grml; ich seh gerad, dass du ja was anderes willst - hab mich von der ersten antwort ablenken lassen und hatte deinen post nur überflogen. nicht ganz so ausführlich, aber der vollständigkeit halber:

    void xyz(const char* str, int& ungerade_ziffern, int& gerad_ziffern, float& durchschnitt, int& min, int& max)
{
  ungerade_ziffern = gerade_ziffern = 0;
  durchschnitt = 0.f;
  min = 9;
  max = 0;

  if(*str == '\0')
  {
    min = 0;
    return;
  }

  do
  {
    int ziffer = *str-'0';
    ++str;

    if(ziffer%2 != 0) ++ungerade_ziffern;
    else              ++  gerade_ziffern;

    if(ziffer < min) min = ziffer;
    if(ziffer > max) max = ziffer;

    durchschnitt += static_cast<float>(ziffer);
  } while(*str != '\0');

  durchschnitt /= static_cast<float>(ungerade_ziffern+gerade_ziffern);
}

#include <iostream>
int main()
{
  int ungerade_ziffern, gerade_ziffern;
  float durchschnitt;
  int min, max;

  xyz("1234", ungerade_ziffern, gerade_ziffern, durchscnitt, min, max);

  std::cout << "..." << std::endl;
}

    bb

    0

  • Output-Parameter hatten wir ja schon.
    Zusätzlich gibt es dann noch Dinge wie std::pair<> und boost::tuple<>, und natürlich kann man ne eigene struct dafür definieren.

    struct BlahValues
{
    int blubb;
    float blobber;
    long long bubblesBubblesBubbles;
};

BlahValues Foo()
{
    BlahValues result = { 1, 2, 3 };
    return result;
}

    @unskilled
    Von const hältst du nicht sehr viel, oder? 🤡

    0

  • hustbaer schrieb:

    ...natürlich kann man ne eigene struct dafür definieren...

    👍

    0
  • Z

    unskilled schrieb:

    edit: @zeusosc: genau. das sollte seine frage beantworten.
    Immerhin hast du ja daran gedacht, dass er ein anfänger ist und leicht
    verständlichen quellcode ohne irgendwelchen zusätzlichen schnick-schnack gepostet 👍

    Naja 🙂 ,
    ich ging davon aus das er
    a) weiß was eine main fkt ist
    b) das er sieht das aus dieser eine Funktion "swap" aufgerufen wird welche
    zwei Argumente bearbeitet.
    c) Das die Funktion void als Rückgabe hat
    d) Das darauffolgend die Art der Zeiger- und Referenzübergabe
    dann etwas mit dem Titel des Threads zu tun hat: "Mehrere Werte zurückgeben".
    e) Das er den Begriff "swap" schon einmal gehört hat und dessen Funktion
    versteht..

    Ich weiß viele Annahmen, ich wollte aber nicht zu viel overhead produzieren..

    Entschuldigt bitte...

    0
  • ?

    hustbaer schrieb:

    Output-Parameter hatten wir ja schon.
    Zusätzlich gibt es dann noch Dinge wie std::pair<> und boost::tuple<>

    Und neuerdings auch std::tuple

    0
  • U

    hustbaer schrieb:

    @unskilled
    Von const hältst du nicht sehr viel, oder? 🤡

    normalerweise schon, aber wollte ihn im ersten post nicht durch x mal const verwirren.

    im 2. hab ich auf die schnelle nix gesehen 😛

    0

  • Nene, eh im ersten.
    float durchschnitt(int* first, int size) und so Sachen, *schüttel*.

    Und mal ne doofe Frage: wieso die ganzen expliziten einFloatWert (operator) static_cast<float>(einIntegerWert) ?
    Die Konvertierung nach float ist in dem Fall doch sowieso implizit.
    Schmeisst dir der Compiler "conversion loses precision" Warnings oder ... 😕

    0
  • U

    hustbaer schrieb:

    Schmeisst dir der Compiler "conversion loses precision" Warnings oder ... 😕

    ich nehms mal an; habs nicht compiliert.

    0
  • O

    zeusosc schrieb:

    Das macht man mit einer call by reference

    krass. Ich bin zuversichtlich, dass das ist das langsamste Swap für ints war, das jemals in diesem Forum gepostet wurde.

    Und ich dachte, ich hätte alles gesehen...definition ein Kandidat für tdwtf

    0
  • 3

    Nicht nur das langsamste, auch das hässlichste. Wenn, dann schon so:

    template <typename T>
void swap(T& a, T& b)
{
    T tmp(std::move(a));
    a = std::move(b);
    b = std::move(tmp);
}

    Oder eben gleich std::swap benutzen.

    0

  • unskilled schrieb:

    hustbaer schrieb:

    Schmeisst dir der Compiler "conversion loses precision" Warnings oder ... 😕

    ich nehms mal an; habs nicht compiliert.

    Dann aber erst recht die Frage: wozu die Casts?

    0
  • U

    weil ich es nicht mag, eine warning zu bekommen, obwohl ich weiß, was ich dort tue.
    hab aber gerad keinen compiler zur hand. wenn ich mich recht entsinne, schmeißt der msvc aber ne warning:

    int main()
{
 int a = 0, float b = 1.f;

 float c = a/b;
}

    vll mags ma jmd mit /W4 compilieren?!

    bb

    0

  • Ah, OK. Ja, mach ich auch so, wenn beim Compilieren grundsätzlich Warnings bekommt, ist das Feature für die Katz.
    War mir jetzt nur nicht ob das "ich nehms mal an; habs nicht compiliert." heissen sollte "ja, das war mein Grund".

    0
  • E

    zeusosc schrieb:

    Das macht man mit einer call by reference

    z.b.:

    void swap(void*_ptr_1 , int & k)
{
int iNt=0;

iNt=*((int*)(_ptr_1));
memcpy(_ptr_1,(void*)&k,sizeof(int));
k=iNt;
}

int _tmain(int argc, _TCHAR* argv[])
{
int a=1;
int b=2;
swap((void*)&a,b);

__debugbreak();

	return 0;
}

    grüße

    Was'n Quatsch.

    Das taugt höchstens für sowas: http://www.ioccc.org/
    ist aber mit Sicherheit in keinster Weise eine Hilfe für iso89.

    0
Anmelden zum Antworten