Zufallstexte

[M. T. (yohojoe)]

So hallo erstmal,

ich sitz hier schon stunden lang vor einer mir gestellten aufgabe in 
informatik (c#). Anhängend einer kleiner teil der aufgabenstellung der 
mir ziemlich schwer fällt.

http://s14.directupload.net/images/130403/b8ak6k95.png

schritt 1 lässt sich ziemlich einfach bewältigen: (nur relv. 
codestellen)

#define MAXLEN 5
srand(time(NULL));
int rdmnum = rand() % MAXLEN +1;

schritt 2: soweit ich es verstanden habe sollen in diesem puffer eine 
zufällige anzahl zufälliger buchstaben zusammengeführt werden (in einem 
späteren teil der aufgabe werden diese im puffer stehenden zeichenketten 
in ein array übernommen).

Dafür brauche ich den memory allocation befehl (malloc) und ich muss 
wissen wie groß der reservierte speicher sein soll: (maximale länge der 
zeichenkette + 2 zeichen für die terminierung die meines wissen so 
aussieht: \0)

char *puffer;
    puffer = (char*) malloc (MAXLEN+2);

schritt 3: hier setzt es bei mir aus da ich die aufgabenstellung gar 
nicht verstehe. Um wenigstens etwas vorran zu kommen habe ich die 
zufallsbuchstaben nochmal als eigenen "zufallsgenerator" geschrieben:

char rdmchar = 64 + (rand() % CHAR +1);

dieser gibt mir also die buchstaben A-Z zufällig aus

schritt 4: ??


mein ganzer code sieht mom. so aus:

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>
#define MAXLEN 5
#define CHAR 26
#define CHARCNT 10

int main()
{

 1   srand(time(NULL));

 2   int rdmnum = rand() % MAXLEN +1;

 3  char rdmchar = 64 + (rand() % CHAR +1);


 4   char *puffer;
 5   puffer = (char*) malloc (MAXLEN+2); 

 6   char* strncat(puffer, rdmchar, rdmnum);

 7   printf("%s\0", puffer);




 8  return 0;
}

Die Ausgabe sind lediglich immer nur 3 Zeichen davon sind die ersten 2 
statisch also verändern sich nicht bei einem neustart lediglich das 
letzte ist zufällig: ϸ↕

Ich selber kann mir nicht erklären warum der code nicht dass macht was 
ich eigentlich erwartet hätte ich denke allerdings der fehler liegt 
zwischen zeile 4 - 6.

Kann mir jemand helfen und mir meinen Fehler aufzeigen?

MfG

Ps: Bekomme mit angehängter datei einen internal server error wenn ich 
zur vorschau will

[... (Gast)]

klitzekleine Hilfe ;)

mach mal einen neuen char* und kopiere da deinen rdmchar rein, weil:
char* strncat(char* destination, char* source, size_t num);

[Arc N. (arc)]

Ein paar Anmerkungen...
Was liefert malloc zurück und wie müssen Zeichenketten in C aufgebaut 
sein damit Funktionen wie strncat richtig arbeiten können?
strncat s.o. zudem sollte der Compiler an der Stelle (6) mindestens eine 
Warnung ausgegeben haben (eigentlich einen Fehler und das Programm nicht 
übersetzen).

[M. T. (yohojoe)]

Arc Net schrieb:
> Ein paar Anmerkungen...
> Was liefert malloc zurück und wie müssen Zeichenketten in C aufgebaut
> sein damit Funktionen wie strncat richtig arbeiten können?
> strncat s.o. zudem sollte der Compiler an der Stelle (6) mindestens eine
> Warnung ausgegeben haben (eigentlich einen Fehler und das Programm nicht
> übersetzen).


malloc ist doch eigentlich ein void liefert also gar nichts zurück, ich 
habe hier aber einen char deswegen muss ich doch zusätzlich einen 
(char*) mit hinschreiben.

ich glaube ich sehe einen fehler:

zeile 3 generiert nur einen buchstaben, daraus folgt dass strncat gar 
nicht mehrere zeichen verketten kann da nur eines generiert wird.
Als lösung müsste man folglich dafür sorgen dass zeile 3 öfters 
ausgeführt wird und zwar mind. so oft wie MAXLEN?


Warnungen/errors werden keine angezeigt :/ (CodeBlocks ver. 10.05)

[Uwe (Gast)]

Funktionen auf strings benötigen zwingend eine 0x00 Byte als 
terminierung
 ( Also solche Funktionen wie strncat).

[Karl H. (kbuchegg)]

M. T. schrieb:
> Arc Net schrieb:
>> Ein paar Anmerkungen...
>> Was liefert malloc zurück und wie müssen Zeichenketten in C aufgebaut
>> sein damit Funktionen wie strncat richtig arbeiten können?
>> strncat s.o. zudem sollte der Compiler an der Stelle (6) mindestens eine
>> Warnung ausgegeben haben (eigentlich einen Fehler und das Programm nicht
>> übersetzen).
>
>
> malloc ist doch eigentlich ein void liefert also gar nichts zurück,

nicht ganz.

malloc liefert einen void*. Und das ist ein Unterschied. Denn malloc 
liefert damit eine Adresse zurück und das void sagt lediglich aus, dass 
nicht weiter klar ist, worauf (also auf welchen Datentyp) diese Adresse 
eigentlich zeigt. Das macht aber nichts, denn du weist diese Adresse der 
Pointer Variablen zu und damit ist dann klar, dass dieser Pointer (weil 
er ein char* ist) auf Character zeigt.

> ich
> habe hier aber einen char deswegen muss ich doch zusätzlich einen
> (char*) mit hinschreiben.

Wenn du den schreiben musst, dann programmierst du nicht C sondern C++. 
In C machst du den Cast lieber wieder raus.
Denn: du brauchst ihn nicht
      er kann dir aber einen fiesen Fehler verstecken


> ich glaube ich sehe einen fehler:

ich seh noch einen Fehler.
Du brauchst überhaupt kein strncat.

  einfach den Speicher allokieren
  danach fasst du diesen Speicher wie ein Array auf (ein Array aus
  char) und weist jeder Array-Position einen zufälligen Buchstaben zu


Du verkomplizierst momentan die Aufgabe grundlos.

[Karl H. (kbuchegg)]

> Dafür brauche ich den memory allocation befehl (malloc) und ich
> muss wissen wie groß der reservierte speicher sein soll:
> (maximale länge der zeichenkette + 2 zeichen für die terminierung
> die meines wissen so aussieht: \0)

* warum + 2?
  wenn du einen Text "Hallo" hast, dann hat der 5 Zeichen. Das Array
  muss 6 Zeichen groß sein, weil ja noch das abschliessende \0 da
  mit rein muss.
  Um also einen Text mit n Buchstaben zu speichern, brauchst du ein
  Array der Größe n+1

> (maximale länge der zeichenkette + 2 zeichen für die terminierung

* genau das steht aber nicht in der Aufgabe! In der Aufgabe steht, du 
sollst dir eine zufällige Textlänge bestimmen und den Speicher genau so 
groß anlegen, dass ein derartiger Text da reinpasst. Die zufällige 
Textlänge hast du ja bereits bestimmt:

  int rdmnum = rand() % MAXLEN +1;

in rdmnum hast du eine zufällige Textlänge, die zwischen 1 und MAXLEN 
liegt.
Und genau dafür sollst du Speicher allokieren. Wenn dein Text also aus 
rdmnum Zeichen bestehen soll, wieviel Speicher musst du dann allokieren? 
Na, ja wohl rmdnum+1 chars. Also

  puffer = malloc( rmdnum + 1 );

jetzt zeigt puffer auf einen Speicher, der gross genug ist, um darin 
rmdnum darstellbare Zeichen PLUS das obligatorische \0 Zeichen als 
Abschluss des Strings zu speichern.

Du musst jetzt nur noch entsprechend rmdnum darstellbare Zeichen da 
reinklamüsern und das \0 an die letzte Stelle in diesem 'Array' bringen

   for( i = 0; i < rmdnum; i++ )
     puffer[i] = .............. zufälliges Zeichen bestimmen

   puffer[rmdnum] = '\0';

und fertig. Zumindest dieser Teil der Aufgabenstellung.

[Stefan P. (form)]

M. T. schrieb:
> (maximale länge der
> zeichenkette + 2 zeichen für die terminierung die meines wissen so
> aussieht: \0)

Das ist übrigens nur 1 Zeichen.

[Andreas D. (rackandboneman)]

Bevor Missverständnisse entstehen:

"gestellten aufgabe in informatik (c#)"

Der hier diskutierte Code ist aber C, kein C#. Und wird in einer C# 
Umgebung auch nur im Ansatz als unmanaged Code und mit zusätzlicher 
Nutzung eines Präprozessors laufen.

[Karl H. (kbuchegg)]

> char rdmchar = 64 + (rand() % CHAR +1);
>
> dieser gibt mir also die buchstaben A-Z zufällig aus

Wie das?

Ich weiß zwar nicht, wie du CHAR definiert hast, aber ich würde so 
vorgehen:
Annahme: wir reden vom ASCII Code.

Seh ich mir die Codetabelle des ASCII Codes an, zb die hier

http://www.torsten-horn.de/techdocs/ascii.htm

dann fällt mir auf, dass die ganzen Großbuchstaben alle hintereinander 
kommen. D.h. ich brauch nur Zufallszahlen erzeugen, die genau diese 
Codes abdecken, und die wie einen char behandeln.

Es gibt 26 Großbuchstaben. Also brauch ich erst mal eine Zufallszahl 
zwischen 0 und 26 (exklusive)

    rand() % 26

macht das. Damit hab ich irgendeine Zahl im Bereich 0 ... 25

Zähle ich da noch den ASCII Code von 'A' dazu, dann kriege ich eine 
somit zufällige Zahl, die genau einem der ASCII Codes der Zeichen 'A' 
bis 'Z' entspricht.

Also:

  char rdmchar = 'A' + rand() % 26;

die 26 könnte man noch etwas schöner formulieren. Das ist ja nichts 
anderes als die Differenz der Codes von 'Z' und 'A'. Denn das müssen 
wieder die 26 sein

  char rdmchar = 'A' + rand() % ( 'Z' - 'A' + 1 );

Und fertig. In rmdchar steht der ASCII Code, und zwar irgendeiner, der 
eines der Zeichen aus dem Bereich 'A' bis 'Z' repräsentiert. Gebe ich 
das als char auf den Monitor aus, dann wird die genau diesen Buchstaben 
hinpinseln.

[Borislav B. (boris_b)]

M. T. schrieb:
> vor einer mir gestellten aufgabe in
> informatik (c#)

M. T. schrieb:
> char *puffer;
>     puffer = (char*) malloc (MAXLEN+2);

Wenn das C# ist, fress ich nen Besen...

[Karl H. (kbuchegg)]

Andy D. schrieb:
> Bevor Missverständnisse entstehen:
>
> "gestellten aufgabe in informatik (c#)"
>
> Der hier diskutierte Code ist aber C, kein C#.

Ja, das ist mir auch schon aufgefallen.

In der Aufgabenstellung steht aber eindeutig C.

Und wenn ich hinzufügen darf, finde ich es bezeichnend, wenn ein Schüler 
nicht mal den Namen der Programmiersprache kennt, in der er 
programmieren soll.

[Nilix (Gast)]

Also ich denke die Lösung sieht so aus wenn ich mich nicht verlesen habe 
oder in der Eile vertippt.
Nicht kompilliert und geprüft und sicher verbesserungsfähig.
Aber einfach mal ein Ansatz evtl. hilfts.


#define MAXLEN 20

//====================================================================== 
============================
// Aufrufende funktion muss Speicer bereinigen mit free(char*);
//====================================================================== 
============================
char* func()
{
int i,lenght;
char *ptr,c;


//ermittle zufällige Zeichenlänge
randomize();
while(1)
 {
 lenght=rand();
 if(lenght > 0 && lenght < MAXLEN) break;
 }

//Speicher allokierung
ptr=malloc(lenght+2);
if(ptr == NULL) return(NULL);

//Speicer füllen
for(i=0;i<lenght;i++)
 {
 while(1)
   {
   c=(char) rand();
   if(c > 0x40 && c < 0x5B) break;//A-Z
   }

 ptr[i]=c;
 ptr[i+1]=0x00;
 }


return(ptr);
}

[thomas d. (Gast)]

Karl Heinz Buchegger schrieb:
> Und wenn ich hinzufügen darf, finde ich es bezeichnend, wenn ein Schüler
> nicht mal den Namen der Programmiersprache kennt, in der er
> programmieren soll.

da fehlen mehr als nur die basics ...

[Karl H. (kbuchegg)]

Nilix schrieb:
> Also ich denke die Lösung sieht so aus wenn ich mich nicht verlesen habe
> oder in der Eile vertippt.
> Nicht kompilliert und geprüft und sicher verbesserungsfähig.

:-)
Den Aufruf von randomize() solltest du besser weglassen (wenn randomize 
das macht, was ich denke das es macht). Lass den Zufallszahlengenerator 
arbeiten! Du hilfst ihm nicht dabei gute Zufallszahlen zu erzeugen, wenn 
du bei jedem Aufruf der Funktion ihm ins Handwerk pfuschst. Den srand 
bzw bei dir eben den randomize macht man nur ein einziges mal pro 
Programmlauf! Alles andere ist kontraproduktiv.

Schön finde ich, dass du das Problem der Nicht-Gleichverteilung durch 
die Bereichseinschränkung mittels Modul berücksichtigt und umgangen 
hast. Auch wenn ich nicht glaube, dass sein Lehrer darauf wert legt und 
du durch den Zwangs-randomize diese Bemühung wieder zunichte machst. 
Allerdings ist die Version mit Endlosschleife + Rausbreaken jetzt nicht 
wirklich 'schön'. Aber Schönheit liegt im Auge des Betrachters :-) Nur 
gibt es in deinem Code eine eigentlich naheliegende Lösung dieses 
Schönheitsmakels.


> ptr=malloc(lenght+2);

warum +2 ?

> if(ptr == NULL) return(NULL);
>
> //Speicer füllen
> for(i=0;i<lenght;i++)
>  {
>  while(1)
>    {
>    c=(char) rand();
>    if(c > 0x40 && c < 0x5B) break;//A-Z

Der Compiler kennt schon die ASCII-Codes. Die brauchst du nicht selber 
nachschlagen :-)

     if(c >= 'A' && c <= 'Z') break;

dann brauchst du auch den Kommentar nicht und das ist immer ein gutes 
Zeichen. Eine Codeänderung, die einen Kommentar überflüssig macht, ist 
immer eine gute Änderung.

>    }
>
>  ptr[i]=c;
>  ptr[i+1]=0x00;

Ist eine Fleissaufgabe. Einmal nach beenden der for-Schleife hätte es 
auch getan. Aber: So hat man für den Debugger immer einen schönen String 
im Array.

[Nilix (Gast)]

Hallo Karl Heinz
Du hast recht, ich habe nur mal kurz in 2 Minuten eine lösung gezaubert.
Ich sagte ja Verbesserungswürdig nur als Ansatz gedacht nicht als 
endgültige Lösung.
Danke dennoch für den Hinweiß

[Rolf M. (rmagnus)]

Karl Heinz Buchegger schrieb:
> if(c >= 'A' && c <= 'Z') break;

Oder gleich ganz unabhängig von der Zeichenkodierung:

if (isalpha(c) && isupper(c)) break;

[Andreas D. (rackandboneman)]

"da fehlen mehr als nur die basics ..."

Evtl auch beim Aufgabensteller ... Evtl wurde gedacht da C++ bis auf 
Ausnahmen eine Übermenge von C ist C# es auch (@yohojoe es ist NICHT so, 
C# hat mehr mit Java als mit C++ gemein!) ...

[M. T. (yohojoe)]

1. Ich bin Student kein Schüler

2. Danke, ich hab jetzt zum ersten mal gehört dass C# nicht gleich C 
ist, ich habe es eher für eine andere "schreibweise" von C gehalten.

3. Ja es fehlen womöglich noch ziemlich viele Basics, liegt aber daran 
dass ich E-technik studiere und nicht informatik. Informatik habe ich 
nur eine Vorlesung pro Woche (meiner Meinung nach viel zu wenig), 
weswegen man sich das meiste selber beibringen muss wofür aber sehr oft 
nur wenig zeit bleibt.
Dh. natürlich auch dass ich manche Aufgaben nur mit mir bekanntem 
Werkzeug lösen kann obwohl eine andere Lösung vllt viel einfacher wäre

[M. T. (yohojoe)]

So ich bin jetzt weitergekommen hab die puffer funktion und deren 
beschreibung in ein array. Dazu kommt noch eine Vertauschung von element 
0 und dem letzten element des arrays und die ausgabe des arrays mit 
vertauschung zum vergleich mit dem original. Problem: das programm 
stürzt ab und ich weiß nicht wieso. Kann es evtl. an den warnungen 
liegen die ich weiter unten beschrieben hab? und wie bekomme ich diese 
weg?

leider war vieles davon trial & error bis ich irgendwann noch darauf 
gekommen bin. Va. die pointer bereiten mir noch ziemlich viele Probleme 
:(.

grüße

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>
#define MAXLEN 5
#define CHAR 26
#define ARRAYLENGTH 10

char* zufall (char* buf)
{



    /**** VARIABLEN ****/

    int zufallszahl;
    int i;



    /**** GENERIERUNG DER ZUFALLSZAHL ****/

    zufallszahl = rand() % MAXLEN +1;


    /**** DYNAMISCHE SPEICHERVERWALTUNG ****/

    buf = (char*) malloc (zufallszahl+1);


    /**** BESCHREIBUNG DES PUFFERS ****/

    for(i=0; i<zufallszahl; i++)
    {
       buf[i] = 64 + (rand() % CHAR +1);
    }


    /**** RUECKGABE MIT NULLTERMINIERUNG ****/

    buf[i] = '\0';
    return buf;



    }





int main()
{
        srand(time(NULL));

        char buf;
        int i;
        char* array [ARRAYLENGTH];
        char* hilfs;

        for(i=0; i<ARRAYLENGTH; i++)
        {
            array[i] = zufall(buf);
            printf("%d: %s\n", i+1, array[i]);
        }




        for(i=0; i<ARRAYLENGTH; i++)
        {
            array[i] = zufall(buf);
            hilfs = array[0];
            array[0] = array[ARRAYLENGTH];
            array[ARRAYLENGTH] = hilfs;
            printf("Nach Vertauschung\n\n\n\n");
            printf("%d: %s\n", i+1, array[i]);

        }



    return 0;
}

warning: passing arg 1 of `zufall' makes pointer from integer without a 
cast
warning: passing arg 1 of `zufall' makes pointer from integer without a 
cast

in den zeilen:

array[i] = zufall(buf);

[Arc N. (arc)]

> Kann es evtl. an den warnungen liegen die ich weiter unten beschrieben
> hab?

Ja

> und wie bekomme ich diese weg?

- Was liefert die Funktion zufall zurück und wo wird das gespeichert?
- Als was wird buf in der Funktion zufall verwendet (warum soll buf dann 
nochmal übergeben werden bzw., um etwas Verwirrung zu stiften, warum 
wäre void zufall(char** buf) { ... } richtiger (aber nicht unbedingt 
sinnvoll))

[M. T. (yohojoe)]

> um etwas Verwirrung zu stiften

:D das ist gelungen.

Also die funktion liefert verschiedene chars welche in einem array 
gespeichert sind.

buf wird verwendet als ein array der diesen string speichert?

 for(i=0; i<ARRAYLENGTH; i++)
        {
            array[i] = zufall(buf);
            printf("%d: %s\n", i+1, array[i]);
        }

Also für mich hört sich das richtig an.

Der fehler liegt meiner meinung nach bei den typbezeichnungen und den 
pointern

[M. T. (yohojoe)]

Ich verstehe vor allem den unterschied nicht:


char *buchstabe: pointer buchstabe mit typ char?

char* buchstabe: char pointer der auf die variable buchstabe zeigt??


wofür genau man das brauchen kann ist mir nicht bekannt :(

kann es vielleicht sein dass man beim 2. fall, zb auch einen int* auf 
die variable zeigen lassen kann und so mehrere typen vor der variablen 
haben kann?

[der mechatroniker (Gast)]

Ganz einfach: der C-Compiler ignoriert Leerzeichen (meistens; 
wesentliche Ausnahme ist da, wo ohne Leerzeichen zwei Bezeichner zu 
einem verschmelzen würden).

Beide Schreibweisen sind daher gleichwertig und definieren eine Variable 
"buchstabe", die vom Typ "Zeiger auf char" ist.

[Xilef (Gast)]

Um mal ein bisschen vom Thema abzuschweifen:

Wieso kann man hier malloc eine feste Größe übergeben, ohne 
sizeof(char)? So wie im Post von kbuchegg:

malloc( rmdnum + 1 );

Ist ein char immer ein byte? Ist folgendes richtiger, oder nur 
überflüssig?

malloc( sizeof(char) * (rmdnum + 1) );

[der mechatroniker (Gast)]

Die zweite Schreibweise ist daher an und für sich logischer: char* wäre 
als eine Einheit zu sehen (nämlich der Typ) und buchstabe als die andere 
(nämlich der Name der definierten Variable).

Warum man normalerweise die erste Schreibweise verwendet hängt mit einer 
Unschönheit zusammen, die die Erfinder von C in die Sprache 
hineindesignt haben.

Preisfrage:

Definiert

char* a, b

wirklich zwei Variablen vom Typ "Zeiger auf char"?

Wenn du die Antwort herausgefunden hast, merkst du, was ich mit 
Unschönheit meinte.

[der mechatroniker (Gast)]

> Wieso kann man hier malloc eine feste Größe übergeben, ohne
> sizeof(char)? So wie im Post von kbuchegg:

Weil sizeof(char) per Definition 1 ist. Sprich überall, wo eine Größe 
einer Datenmenge verwendet wird (Parameter von malloc, Ergebnis von 
sizeof) ist die Größe in Vielfachen der Größe eines char gemeint.

[M. T. (yohojoe)]

> Preisfrage:

> Definiert
>

> char* a, b
>

> wirklich zwei Variablen vom Typ "Zeiger auf char"?


nein meines wissens nach nur eine variable vom typ zeiger auf char und 
zwar a.


aber schonmal danke wusste ich davor nicht :)

[Malte S. (maltest)]

M. T. schrieb:
> array[0] = array[ARRAYLENGTH];
>             array[ARRAYLENGTH] = hilfs;

Abgesehen von den angewarnten Stellen und den Problemen mit char vs. 
char* ist array[ARRAYLENGTH] außerhalb von array, das nur ARRAYLENGTH 
Elemente hat. Ganz gefährlicher Fehler sowas.

[Karl H. (kbuchegg)]

M. T. schrieb:
>> um etwas Verwirrung zu stiften
>
> :D das ist gelungen.
>
> Also die funktion liefert verschiedene chars welche in einem array
> gespeichert sind.


Deine Denkweise ist Quatsch.

Diese Funktion

char* zufall (char* buf)
{
  ...
}

liefert einen Pointer. Aus. Ende. Punkt.

Mehr steht da nicht da.

Da du die Funktion geschrieben hast, weißt du, dass dieser Pointer auf 
einen Speicherbereich zeigt, in dem ein Text gespeichert ist. Und das 
reicht dann schon. Die Funktion braucht auch kein Pointer Argument! Wozu 
soll das gut sein? Kein Mensch braucht dieses Argument innerhalb der 
Funktion.

...
int main()
{
  char* pText;

  pText = zufall();

  printf( "%s\n", pText );

  free( pText );
}

[Karl H. (kbuchegg)]

Und zieh deinen Code nicht so in die Länge!
Das bringt dir nichts, wenn du 2 Millionen Leerzeilen einstreust. Alles 
was du damit tust, ist deinen Code unübersichtlicher zu machen, weil du 
ihn rein optisch nicht mehr überblicken kannst.

Deine Kommentare solltest du auch überdenken. Die sind nämlich sinnlos, 
weil sie mir nichts erzählen, was nicht auch im Quelltext steht. Wer bei

    /**** VARIABLEN ****/

    int zufallszahl;
    int i;

nicht innerhalb einer halben Sekunde sieht, dass hier Variablen 
definiert werden, der soll sich doch bitte sein Lehrgeld wiedergeben 
lassen, seine Lehrer haben dann nämlich ganz offensichtlich versagt. Ein 
derartiger Kommentar bewegt sich auf dem Niveau von einem Schild nebem 
einem roten Button zum Drücken, auf dem steht "Dies ist ein roter Knopf 
zum Drücken."
Völlig sinnlos.
Erzähl mir in deinen Kommentaren etwas, was ich nicht im Source Code 
sehe!

    /**** GENERIERUNG DER ZUFALLSZAHL ****/

    zufallszahl = rand() % MAXLEN +1;

das hier eine Zufallszahl generiert wird, sehe ich auch so. Dazu brauch 
ich keinen Kommentar. Aber was macht diese Zufallszahl? Was hat es damit 
für eine Bewandtnis? Wofür wird die verwendet? Warum +1? Wo kommt das 
MAXLEN her? Welche Bedeutung hat dieses?
All das sind beispielsweise Dinge, die mich interessieren würden. Aber: 
Du verrätst sie mir nicht. Dafür verrätst du mir, dass hier eine 
Zufallszahl generiert wird. Da kann ich nur sagen "Gähn - als ob ich das 
nicht durch die Verwendung der Funktion rand() nicht auch selbst gesehen 
hätte"

Sieh dir die Namen deiner Variablen bzw. der Funktionen an! Inwieweit 
erzählen mir die welche Funktion sie innerhalb des Programms erfüllen? 
Gar nicht. Eine Funktion namens 'zufall' erzählt mir nichts, was sie 
tut. Was macht sie denn wirklich? Na, sie erzeugt einen Zufallstext. 
Also wäre es nur folgerichtig, wenn sich dieses auch im Namen 
wiederspiegeln würde! Was macht denn deine Variable 'zufallszahl' 
innerhalb der Funktion? Welche Bedeutung hat die denn? In ihr ist 
gespeichert, wie lange der Text werden soll. Also wäre es nur 
vernünftig, dass sich dieses auch in ihrem Namen wiederspiegelt. In 
erster Linie ist diese Variable die Länge des zu erzeugenden Textes. 
Dass diese Länge durch eine Zufallszahl ermittelt wird, ist zwar nett, 
ist aber ein Detail, welches mich in weiterer Folge nicht wirklich 
interessiert. Irgendwo muss diese Länge herkommen. In diesem Fall ist es 
eben durch eine Zufallszahl. Aber ob das durch eine Zufallszahl gemacht 
wird, oder ob das zb durch eine Benutzereingabe gemacht wird, ändert 
nichts daran, dass sich bei dieser Zahl in erster Linie um die Länge des 
zu erzeugenden Textes handelt - das ist die wichtige Information und 
nicht wie diese Zahl zustande kommt.

char* rndText( void )
{
  int   textLength;
  int   i;
  char* pText = NULL;

  textLength = rand() % MAXLEN + 1;
  pText = malloc (textLength*sizeof(char) + 1);

  for(i=0; i<textLength; i++)
  {
    pText[i] = 'A' + (rand() % CHAR +1);
  }
  pText[i] = '\0';

  return pText;
}

Sieh dir diese Funktion durch. Zum Beispiel die Zeile

  textLength = rand() % MAXLEN + 1;

Braucht es da noch irgendwelche Kommentare? Nicht wirklich. Im 
Programmtext selber steht, was da passiert. Da wird die Länge des Textes 
'erzeugt'. Das kann ich unmittelbar daran ablesen, dass eine Variable 
namens textLength einen Wert bekommt. Ich kann auch ablesen, dass dieser 
Wert sich irgendwie aus einer Zufallszahl ermittelt. Das einzige was 
nicht ablesbar ist, ist was es mit dem MAXLEN auf sich hat.
AUch ist für die Funktion insgesammt nicht ablesbar, welche Regeln für 
die  'Buchstaben' innerhalb des Textes gelten (ob da zb nur 
Grossbuchstaben enthalten sein werden, oder auch Kleinbuchstaben. Ob man 
mit Ziffern rechnen muss und/oder Sonderzeichen und wenn ja mit 
welchen). Das sind die Dinge, die kommentiert werden müssen und nicht, 
dass da jetzt ein Return gemacht wird. Denn das seh ich auch im Code 
selber. Dazu brauch ich deine Kommentare nicht, damit ich das sehe. So 
blind bin ich nicht.

Im Kommentar steht das WARUM. Im Code steht das WIE.

[M. T. (yohojoe)]

Malte S. schrieb:
> Abgesehen von den angewarnten Stellen und den Problemen mit char vs.
> char* ist array[ARRAYLENGTH] außerhalb von array, das nur ARRAYLENGTH
> Elemente hat. Ganz gefährlicher Fehler sowas.

EDIT: Hab grad herausgefunden was du meinst, in die klammer gehört 
[ARRAYLENGTH-1]. Da es zwar 10 werte hat, es aber von 0 - 9 geht ist 
ARRAYLENGTH mit 10 gar nicht vorhanden, deswegen auch der absturz. 
Ziemlich leichtsinniger Fehler von mir


Also die warnung sind weg, hatte in der main buf als variable deklariert 
obwohl es eig ein pointer sein sollte.

Das was du hier angibst sollte eigentlich eine vertauschung sein vom 
ersten mit dem letzten array element.

Allerdings ist es in der Aufgabenstellung so beschrieben, dass man die 
vertauschung in einer funktion erreichen soll, der die arrayeinträge als 
argumente übergeben werden. Mal sehn was ich daraus machen kann. Es ist 
nur ziemlich niederschlagend wenn jeder aufgabenteil an die 5 stunden 
braucht und hinterher ist er auch noch falsch....