Struct Array füllen

[Stefan (Gast)]

Hallo ich habe folgenden Ausschnitt eines Programmes:

int zufall(a, b);

struct{
unsigned int a;
char x[1];
};
int main(void){
typedef struct zufall Zufall;
Zufall array[100];
// Ich will jetzt über die Funktion die x Elemente von array mit einem //Großbustaben belegen
// So wäre es kein Problem: array[1].x='A' +rand()%26 usw.. für die anderen //Elemente
//Nun soll es aber laut Aufgabenstellung über die Funktion gemacht werden.
//Nur wie soll das gehen die Funktion liefert doch einen int Wert zurück kein Zeichen?
}
int zufall(a, b){
int zufzahl;
srand(time(NULL));
zufzahl = a + rand()% (b-a)
return zuzahl;
}

Kennt sich da wer aus?

1001 Dank
Stefan

[Peter II (Gast)]

Stefan schrieb:
> Nur wie soll das gehen die Funktion liefert doch einen int Wert zurück kein 
Zeichen?

und weg sagt das? ein funktion kann alles mögliche zurück liefern auch 
einen int.

[Karl H. (kbuchegg)]

Stefan schrieb:

> //Nur wie soll das gehen die Funktion liefert doch einen int Wert zurück
> kein Zeichen?

Psst.

Zeichen in dem Sinne gibt es in einem Computer gar nicht.
Ein char ist auch nichts anderes als eine Variable in der eine Zahl 
gespeichert wird.
Lediglich bei der Ausgabe werden char anders behandelt, in dem die Zahl 
als ASCII Code eines Zeichens aufgefasst wird. Dies sorgat dann dafür, 
dass auf der Anzeige nicht 65 auftaucht, sondern die Pixel gesetzt 
werden, so dass du 'A' liest. Aber in der char Variablen selber steht 65 
drinnen.

Es spricht nichts dagegen mit char Variablen zu rechnen. So gesehen sind 
das einfach nur Integer Variablen für kleine Zahlen. Behandelt man sie 
bei der Ausgabe/Eingabe mit einer Character Sonderbhandlung, dann wird 
diese Zahl als ASCII Code aufgefasst. Aber mehr steckt da nicht 
dahinter.

In C hat ein char keine großartige Sonderrolle, wie in anderen 
Programmiersprachen. Es ist einfach nur eine Variable für kleine Zahlen, 
die bei I/O anders behandelt wird als beispielsweise ein int. Aber man 
kann und darf mit denen genauso rechnen, wie auch mit anderen 
Datentypen. Man muss lediglich aufpassen, weil nicht klar festgelegt 
ist, ob die Dinger jetzt ein Vorzeichen haben oder nicht. Aber bei dir 
spielt das keine Rolle.

  int j = 5;
  char c = '0' + j;

ist in C absolut fein. In c steht dann der ASCII Code für das Zeichen 
'5' drinnen, weil die ASCII Codes so angeordnet sind, dass die Codes für 
die Ziffern alle aufeinander folgend sind. Und vom Code für '0' 
ausgehend, 5 Codes weiter, landet man dann beim Code für '5'.

Du hast ja auch hier gerechnet
array[1].x='A' +rand()%26

wenn du dir nun von der Funktion zufall() eine 'Zufallszahl' berechnen 
lässt, die zwischen den ASCII Codes für 'A' und dem ASCII COde von 'Z' 
liegt, dann ist doch alles in Ordnung

   array[1].x[0] = zufall( 'A', 'Z' );

zufall interessiert sich ja nicht dafür, was die Zahlen bedeuten, die du 
als untere und obere Grenze mitgibst. Das können genausogut auch ASCII 
Codes von Charactern sein :-) Und da du weißt, dass zufall nichts 
ausserhalb dieses Bereichs liefern wird, kannst du das auch einfach 
einem char zuweisen. Denn Zufall liefert dir eine Zahl (die aufgrund der 
Argumente nur ein ASCII Code zwischen 'A' und 'Z' sein kann) und im char 
werden genau solche ASCII Codes gespeichert.


  char c = 65;
  char c = 'A';
  char c = 0x41;
  char c = 0101;
  char c = 0b01000001;  // auf dem GCC

unterscheidet sich in nichts. Es sind nur unterschiedliche 
Schreibweisen. Nach Abschluss der Operation hat das Byte c das Bitmuster 
01000001.
Aber logischerweise nimmt man immer die Schreibweise, die die Absicht am 
Besten ausdrückt. Aber abgesehen davon, sind alle diese Schreibweisen 
untereinander austauschbar, eben WEIL sie alle genau die gleiche 
Operation ausdrücken.

[Stefan (Gast)]

@  Karl Heinz Buchegger: Ich zitiere mal nicht deinen ganzen Text. 
Vielen Dank für deine Antwort. Super erklärt das ganze!

[Karl H. (kbuchegg)]

PS:

int zufall(a, b){
  int zufzahl;
  srand(time(NULL));
  zufzahl = a + rand()% (b-a)
  return zuzahl;
}

Der srand da drinnen ist KEINE gute Idee!
srand ruft man EINMAL in einem Programmlauf auf. Normalerweise macht man 
das am Anfang von main().
Aber vor jedem rand() einen srand() aufzurufen hat Konsequenzen! 
Zufälligkeit ist keine Eigenschaft einer einzelnen Zahl. Ist 5 zufällig? 
Oder 8?
Nö. Zufälligkeit ist eine Eigenschaft einer Zahlenfolge. Einer 
Zahlenfolge, die dadurch entsteht, dass rand() öfter aufgerufen wird. 
Dazu muss rand() aber arbeiten können! Der hinter rand() stehende 
Formalismus ist so ausgetüftelt, dass die Pseudozufallszahlen 
auseinander entstehen. Mischt du dich da mit dauernden srand() Aufrufen 
ein, dann kann sich die Eigenschaft 'Pseudozufälligkeit' nicht aufbauen. 
Durch das srand() zerstörst du sie. Deine Zahlenfolge ist nicht mehr 
(pseudo)-zufällig.

[Stefan (Gast)]

Karl Heinz Buchegger schrieb:

> Der srand da drinnen ist KEINE gute Idee!
> srand ruft man EINMAL in einem Programmlauf auf. Normalerweise macht man
> das am Anfang von main().
> Aber vor jedem rand() einen srand() aufzurufen hat Konsequenzen!
> Zufälligkeit ist keine Eigenschaft einer einzelnen Zahl. Ist 5 zufällig?
> Oder 8?
> Nö. Zufälligkeit ist eine Eigenschaft einer Zahlenfolge. Einer
> Zahlenfolge, die dadurch entsteht, dass rand() öfter aufgerufen wird.
> Dazu muss rand() aber arbeiten können! Der hinter rand() stehende
> Formalismus ist so ausgetüftelt, dass die Pseudozufallszahlen
> auseinander entstehen. Mischt du dich da mit dauernden srand() Aufrufen
> ein, dann kann sich die Eigenschaft 'Pseudozufälligkeit' nicht aufbauen.
> Durch das srand() zerstörst du sie. Deine Zahlen sind nicht mehr
> (pseudo)-zufällig.

Ok, dies habe ich nicht beachtet werde das ändern. Danke für den 
Hinweis.