Funktionsrückgabe in C (Bitspielereien)

[Da Mo (Gast)]

HILFEEEE :-)

Ich habe zu folgender Aufgabenstellung, das folgende Programm 
geschrieben. Ich weiß nur nicht, wie ich die Rückgabe der Positionen 
umsetzen kann.

***
Aufgabenstellung:

Gesucht ist eine Funktion, welche die Position der ersten 2 Einsen eines 
8-Bit-Wert zurückliefert.
***

// Uebungsbeispiel 4

#include<stdio.h>
/*********************************************************************** 
*******/
int bitsearch(unsigned char);
/*********************************************************************** 
*******/
int main(void)
{
 unsigned char data;
 int stellen;

 printf("Bitte geben Sie einen Wert ein(max. 0xFF): ");
 scanf("%x", &data);
 printf("\n");
 printf("Die ersten 2 Einesn sind an folgenden Stellen: \n\n");
 stellen = bitsearch(data);

 system("pause");
 return 0;
}
/*********************************************************************** 
*******/
int bitsearch(unsigned char data)
{
 unsigned char mask = 0x01;
 int i;
 int counter1 = 0;
 int counter2 = 0;

 for(i = 0; i <= 7; i++)
 {
  if(counter2 <= 1)
  {
   if((data&mask)!=0)
   {
    printf("Stelle: %i\n\n", counter1);
    counter2++;
   }
   counter1++;
   mask = mask <<1;
  }
 }
 return counter1;
}
/*********************************************************************** 
*******/

[Nils S. (kruemeltee)]

Dominik M. schrieb:
> Gesucht ist eine Funktion, welche die Position der ersten 2 Einsen eines
> 8-Bit-Wert zurückliefert.

Aha....

Dominik M. schrieb:
> // Uebungsbeispiel 4

Mach deine Hausaufgaben selbst.

[Udo S. (urschmitt)]

Dominik M. schrieb:
> Gesucht ist eine Funktion, welche die Position der ersten 2 Einsen eines
> 8-Bit-Wert zurückliefert.

Ist das die Aufgabenstellung oder dein Lösungsansatz?

Eine Funktion kann im Rückgabewert nur eine Variable zurückgeben.
Du möchtest aber 2 Werte haben.
Jetzt gibt es verschiedene Möglichkeiten:
Diese Variable kann natürlich ein Zeiger auf einen Struct sein.
Du kannst einen Wert zurückgeben in den du deine 2 Werte hineinkodieren 
kannst (z.B. ein unsigned int kann 2 unsigned char beinhalten)
Du kannst statt dessen der Funktion Zeiger auf Werte im Hauptprogramm 
übergeben, die Funktion setzt dann diese Werte.

Es wird hier im Forum nicht gerne gesehen daß jemand versucht sich seine 
Hausaufgaben machen zu lassen. Aber wenn jemand ein Problem hat und 
konkrete Fragen dazu wird er nicht im Regen stehen gelassen.

[Karl H. (kbuchegg)]

Da du noch am Anfang deiner C-Karriere stehst und du daher 
wahrscheinlich noch nichts mit struct zu tun hattest, sollte deine 
Denkweise so sein

wieviele Return-Werte brauche ich?

* genau einen:  ->  ich kann das Ergebnis als Returnwert der Funktion
                    mit einem "return" herausschleusen

* mehrere:      ->  Der Aufrufer der Funktion übergibt eine
                    entsprechende Anzahl von Variablen "per Referenz"
                    (in C also mit einem Pointer) und die Funktion
                    beschreibt über diesen Pointer die Variablen

int Quadrat( int x )
{
  return x * x;
}

int main()
{
  int j = Quadrat( 5 );
}

versus

void GibWerte( int *wert1, int* wert2 )
{
  ...
  *wert1 = 5;
  *wert2 = 8;
}

int main()
{
  int i, j;

  GibWerte( &i, &j );
}

und noch was:
Schreib for-Schleifen immer in der Form

  for( i = 0; i < 8; i++ )

und nicht

  for(i = 0; i <= 7; i++)

beide Schleifen werden gleich oft durchlaufen und auch mit der gleichen 
Anzahl oft durchlaufen. Trotzdem ist die erste Form zu bevorzugen, weil 
in der Schreibweise die Anzahl der Wiederholungen direkt ablesbar ist. 
Wenn du dann irgendwann mit Arrays arbeitest, wird die erste 
Schreibweise nämlich die wesentlich wichtigere werden! Eine derartige 
Schleife ist in C die 'natürlichere', die alle C Programmierer mit einem 
Blick erkennen und eindeutig identifizieren. Deine Schreibweise sieht 
anders aus und fast alle C-Programmierer müssen sich erst einmal klar 
machen, dass sie identisch zur ersten ist, während sie bei der ersten 
Form nicht lange überlegen müssen. Das <= da drinnen ist sowas wie ein 
Auslöser des Gedankengangs: "Hoppla, die Schleife sieht anders aus als 
eine normale Zählschleife. Warum ist das so?"


PS: Man kann diese spezielle Funktion allerdings tatsächlich mit nur 
einem Return-Wert schreiben. Man muss sich nur für den Returnwert etwas 
einfallen lassen. Der kann ja für jede 1 nur im Bereich 0 bis 7 sein. 
Ich kann aber zb vereinbaren, dass die erste 1 in der Einerstelle des 
Returnwertes codiert ist und die 2te in der Zehnerstelle. Eine Rückgabe 
von 63 würde also bedeuten, dass die erste 1 an der Position 3 war und 
die zweite an der Position 6.

In wie weit das sinnvoll ist, musst du entscheiden. Machbar wäre es.