Hi,

ich hab mir schon ein paar Tutorials durchgelesen, die ich aber nicht im Bezug auf mein Bsp verstehe.

Ich weis nur das malloc() Bytes von z.B. Integer reserviert(Oder?), aber wie und was man genau darunter versteht leider nicht.

Darum hier mal ein Bsp(Fragen stehn in den Comments):

Code cpp:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67

#include <stdio.h> #include <stdlib.h>   #define MAX_STRLEN   int get_lineno(FILE *infile);//ermittelt die Länge, also die Zeilen der .txt Datei   void main() {   char filename[MAX_STRLEN]="daten_in.txt";   int file_len = 0;   FILE *inFile=NULL;   double *arrayValues=NULL;//was bedeutet das genau mit NULL im Bezug auf Pointer?   double *actVal = NULL;//gleiche wie oben   int n=0;     inFile=fopen(filename,"rt");//liest aus .txt datei   if (inFile != NULL) //inFile wird NULL wenn Datei ende oder ein andere Fehler auftritt oder? Was wären den solche "anderen Fehler" z.b?   {     file_len=get_lineno(inFile);//unterprogrammaufruf, file_len=dateilänge, Anzahl der Zeilen     rewind(inFile);     arrayValues=malloc(sizeof(double)*file_len);//Wie schon gesagt reseviert der Befehl Bytes(falls das erwähnte stimmt :D) Double-Bytes oder? Aber bitte erklärt einfach die ganze Zeile     if (arrayValues != NULL)//Warum schreibt man hier arrayValues ungleich NULL?     {         actVal=arrayValues;//Warum soll actVal = arrayValeus sein? Was hat das für einen Sinn? Warum nicht mit arrayValues weiter machen?       for(n=0; n<file_len; n++)       {         fscanf(inFile,"%lf",actVal);         actVal++;//Hier zeigt es immer um eins weiter auf die nächste Speicherstelle in eine Adresse, wo man Werte speichern kann oder?       }       actVal=arrayValues;//gleiche wie oben       for(n=0; n<file_len; n++)       {         printf("%lf\n",*actVal);         actVal++;//gleiche wie oben       }       free(arrayValues);//Naja, free=frei Speicherfreigabe vielleicht? Wenn ja was ist darunter genau gemeint?     }     else     {       printf("Memory allocation failure for Data of File %s !\n",filename);     }         fclose(inFile);   }   else   {     printf("File %s could not be opened!\n",filename);   }     //getchar(); }     int get_lineno(FILE *infile) {   int len =0;   double dummy;     while (!feof(infile))   {     if (fscanf(infile,"%lf",&dummy) == 1)     {       len++;     }   }   return (len); }

lg Googlehupf

Hi

zuerst get_lineno: Das funktioniert so nur dann, wenn die Zeile nur aus Kommazahlen besteht,
genau eine pro Zeile. Das sollte man etwas universeller programmieren.
fgets usw.

NULL bei Pointern steht für "zeigt auf nichts".
NULL ist (mit ein paar Besoderheiten) nur ein Name für die Zahl 0.
Da es im RAM aber keine Dresse 0 gibt, auf die gezeigt werden kann,
wurde das als "nichts" festgelegt.
Wenn man NULL nicht am Anfang zuweist, steht irgendeine Adresse im Pointer, ein Zufallswert, der als Adresse eigentlich gar nicht zum Programm gehört. Würde theoretisch nicht stöfen, wenn man erst später eine Adresse reinschreibt (bevor man den Pointer verwendet).
Wenn man aber immer konsequent NULL reinmacht, wenn er auf nichts zeigen soll, kann man das auch in if usw. abfragen.

Zum fopen: Ja, das öffnet die Datei.
Statt "rt" wäre aber "r" angebrachter. Für read. Wozu das t?

Das if...==NULL darunter: Nein, da gehts nicht um Dateienden usw.
Nur darum, ob fopen geklappt hat.
Wenn man einen Dateinamen zum read angibt, zu dem es keine Datei gibt,
das wäre so ein NULL-Fall.
Wenn fopen aber funktioniert hat, bekommt man die Adresse (Pointer) auf eine FILE-Variable,
in der für die Lesefunktionen Infos zur Datei sind.

Unterprogrammaufruf: Das stimmt soweit alles.
Allerdings ist es (für andere Leser außer dich) verwirrend,
die Zeilenanzahl als Dateilänge zu bezeichnen.
Nenns doch zeilenanz oder so.
Bei Dateilänge denkt man zuerst immer an die Byteanzahl in der Datei.

Zum malloc:
Zunächst einmal zwei Vor-Informationen:
a) Pointer können ja (wie wahrscheinlich bekannt) auf schon vorhandene Variablen zeigen,
so zB.:

Code cpp:

1 2 3

int a; int *b; b = &a;

b) Ein Array ist im Grunde auch ein Pointer.
Bei einem Array ist die Variable selbst ein Pointer auf das erste ([0]) Arrayelement.
Die einzelnen Arrayelemente sind im Speicher direkt hintereinander,
ohne etwas dazwischen.
Und wenn man jetzt array[2] nimmt, ist das "das Startelement und zwei Variablen weiter"
(array[0] ist das Startelement und 0 weiter...deshalb beginnts bei [0]...)

Wenn man also ein int-Array hat, angenommen mit 4 ints (zu je 4 Byte):
Das "Startint" hat zB. die Adresse 100 (und besetzt auch 101, 102 und 103)
Das Nächste ist ab 104, das Dritte ab 108, das letzte ab 112

Wenn man jetzt auf meinarray[2] zugreift, ist meinarray zuerst mal ein Pointer
auf die Adresse 100. Ein int hat 4 Byte, und man muss zwei int weiter.
Daraus rechnet sich der Computer dann 108 aus, und nimmt das int von der Adresse her.

Bei deinem malloc hast du jetzt kein Array, aber einen Pointer.
Nur einen Pointer. Dem du jetzt mit malloc ein neues Array erzeugst,
wirklich Speicher für die Variablen reservierst.

Du willst die Kommazahlen in der datei abspeicher, jede Zeile hat eine.
Also sinds soviel doubles wie Zeilen.
Wieviel byte ein double hat, bekommt man mit sizeof, und das mal die Anzahl.
Ergibt, wieviel Byte man für dein neues double-Array braucht.

Das if danach: Wenn malloc ein Problem hatte (zB nicht mehr genug freier Speicher im Computer oder so) komt NULL zurück, statt der Startadresse des neuen Speichers.

so, geht gleich weiter.

Hi.

Zitat von Googlehupf

Ich weis nur das malloc() Bytes von z.B. Integer reserviert(Oder?),

malloc reserviert / alloziert einfach Speicher. Punkt.

Zitat von Googlehupf

aber wie und was man genau darunter versteht leider nicht.

Was meinst du denn mit wie? Wie es das macht?

Zitat von Googlehupf

int get_lineno(FILE *infile);//ermittelt die Länge, also die Zeilen der .txt Datei

Die Funktion macht nicht mal annähernd das was als Kommentar da steht....

Zitat von Googlehupf

void main()

Es muß int main heißen.

Zitat von Googlehupf

double *arrayValues=NULL;//was bedeutet das genau mit NULL im Bezug auf Pointer?

Das bedeutet, dass der Zeiger auf nichts zeigt.

Zitat von Googlehupf

if (inFile != NULL) //inFile wird NULL wenn Datei ende oder ein andere Fehler auftritt oder? Was wären den solche "anderen Fehler" z.b?

inFile ist NULL wenn die Datei nicht geöffnet werden konnte. Siehe Doku zu fopen. In errno steht ein Fehlercode.

Zitat von Googlehupf

arrayValues=malloc(sizeof(double)*file_len);//Wie schon gesagt reseviert der Befehl Bytes(falls das erwähnte stimmt ) Double-Bytes oder? Aber bitte erklärt einfach die ganze Zeile

Datentypen haben ein bestimmte Größe. Um einen double zu speichern, benötigt man üblicherweise 8 Bytes.

Wenn man 20 double speichern will, braucht man also 20 * 8 Bytes Speicher.

Zitat von Googlehupf

if (arrayValues != NULL)//Warum schreibt man hier arrayValues ungleich NULL?

Weil malloc NULL zurückgibt, wenn es keinen Speicher reservieren konnte.

Zitat von Googlehupf

actVal=arrayValues;//Warum soll actVal = arrayValeus sein? Was hat das für einen Sinn? Warum nicht mit arrayValues weiter machen?

Weil man sich den ursprünglichen Wert (genau den den malloc zurückgegebn hat) speichern muss, damit man irgendwann free damit aufrufen kann.

Zitat von Googlehupf

actVal++;//Hier zeigt es immer um eins weiter auf die nächste Speicherstelle in eine Adresse, wo man Werte speichern kann oder?

Ja, prinzipiell schon. Es zeigt auf den nächsten double Wert in dem Array.

Zitat von Googlehupf

free(arrayValues);//Naja, free=frei Speicherfreigabe vielleicht? Wenn ja was ist darunter genau gemeint?

Da kuckst du einfach mal in eine Referenz. Steht ganz genau da...

Gruß

PS: Da du deine Fragen einfach in den Code geklatscht hast, hab ich den Code einfach zwischen meine Antworten geklatscht...

Zitat von sheel

Zum fopen: Ja, das öffnet die Datei.
Statt "rt" wäre aber "r" angebrachter. Für read. Wozu das t?

Textmode - im Gegensatz zu Binarymode "b". (das t hat üblicherweise keine Wirkung, kann mal also weglassen)

Gruß

So, oben noch was hinzufügt.

Der Rest kommt hier:

Code cpp:

1 2 3 4 5 6

actVal=arrayValues; for(n=0; n<file_len; n++) {    fscanf(inFile,"%lf",actVal);    actVal++; }

Da werden alle doubles (es sind ja soviele wie Zeilen) eingelesen
und in arrayValues gespeichert.
Dieser Code wäre das Gleiche:

Code cpp:

1 2 3 4

for(n=0; n<file_len; n++) {    fscanf(inFile,"%lf", &actVal[n]); }

So ist es klarer, oder?
So, wie es bei dir ist, holst du dir die Adresse des Startelements vom Array.
Liest das double dorthin ein. Und gehst mitdem actual-Pointer ein double weiter.
Einlesen, weiter...so oft, wie Zeilen in der Datei sind.


free sagt einfach "den Speicher, den ich mit malloc da bekommen habe,
brauch ich jetzt nicht mehr".

Gruß

Ok, danke.

Jetzt verstehe ich das Programm. Aber dieses malloc() ist mir noch nicht ganz klar. Wenn ich jetzt das malloc() und die If + else und free() weglasse und dann mit Einzelschritt F11 durchgehe kommt in Zeile 29 eine Fehlermeldung:

Unbehandelte Ausnahme bei 0x61d29348 in dynmem.exe: 0xC0000005:
Zugriffsverletzung beim Schreiben an Position 0x00000000.

Warum kommt die Fehlermeldung?
Ja, weil ich malloc() weggelassen habe schon klar
Kann man das net anders erklären?

Zu malloc():

Code cpp:

1	arrayValues=malloc(sizeof(double)*file_len);

file_len ist ja die Anzahl an Zeilen, also im unserem File auch die Anzahl der double-Zahlen.
file_len=4
sizeof(double) sagt ja wie viel Byte 1 double hat --> 8*4=32 Bytes werden reserviert?

Und die 32 Bytes kommen dann wo hin bzw. was macht man damit?

Du willst die Kommazahlen in der datei abspeicher, jede Zeile hat eine.
Also sinds soviel doubles wie Zeilen.
Wieviel byte ein double hat, bekommt man mit sizeof, und das mal die Anzahl.
Ergibt, wieviel Byte man für dein neues double-Array braucht.

Was meintest du mit double-Array? So ein array mit index und so? z.b: array[100]?

Wenn ja wo bei malloc kommt das vor?

Wenn du mit "double abc[100]" ein Array machst,
besorgt der Compiler für dich 800 Byte und füllt die Adresse des ersten in den Pointer abc.

Bei "double *abc" hast du nur den Pointer, ohne die 800 Byte, die deinem Programm gehören.
Die besorgst du mit malloc (Hallo Windows, ich hätte gern 800 Byte vom Speicher für mich).
malloc gibt dir auch wieder die Adresse in abc rein.

Das if-NULL ist dann eben, wenn Windows keine 800 Byte hergegeben hat.

Und free: Da, Computer, hast du deine 800 Byte wieder, brauch ich nicht mehr.


Ein Array ist also nichts anderes als ein Pointer,
nur im einen Fall schon mit Speicherplatz versorgt.
Und egal, mit welcher der zwei Methoden du abc gemacht hast,
kannst du immer mit "abc[...]" auf die einzelnen doubles zugreifen.

malloc() in einer Unterprogramm nutzen und dann mittels dem vom Unterprogramm zurückgegebenen Wert, den man von malloc bekommt, im Hauptprogramm freigeben ist ja nicht so schwer.

Code cpp:

1	wert=malloc(.....);

Aber was macht man wenn man 2 oder mehr Speicher anfordern muss? Ich habe zwar kein konkretes Bsp dafür, aber sagen wir mal ich muss aus einer Textdatei was auslesen und ich speichere alle Ganzzahlen in eine Variable a auf der ein Pointer zeigt und alle Kommazahlen in eine Variable b auf der auch ein Pointer zeigt.

Und für diese 2 Pointer muss ich ja 2mal malloc() verwenden also Speicher anfordern. Aber wo geben ich dann den Speicher frei? Eigentlich ganz am Ende, also im Hauptprogramm am Schluss, aber mit return kann ich ja nur einen Wert übergeben, aber ich bekomme ja 1 Wert vom malloc(pointer a) und 1 Wert von malloc(pointer b), also muss ich 2mal Speicher freigeben.

z.B. so:

Code cpp:

1 2 3 4 5 6 7 8 9 10 11 12 13 14

typ zahlen(filename[]...)// für typ halt irgendein datentyp(int*, double*, void...) {   int* a;   double* b;     a=(int*)malloc(sizeof(int)*anzahl)//anzahl=wie viel ganzezahlen vorkommen.... und a ist der Wert mit dem man den Speicher freigeben muss   b=(double*)malloc(sizeof(double)*anzahl1)//anzahl1=wie viele kommazahlen vorkommen... und b ist der wert mit dem man den Speicher freigeben muss     while(!feof(file))   {      fscanf(.......)     }   }

Der Code ist nur schnell hingetippt, da ich nur das mit dem malloc zeigen wollte

Wie ich oben schon geschrieben habe, falls ich nur ein malloc nutze kann ich ja den vom malloc bekommenden Wert zurück ins Hauptprogramm geben und damit den Speicher freigeben, aber in dem Bsp da hat man 2.

Die Frage nochmal: Wie gebe ich nun den Speicher frei? Also wie kann ich dem im Hauptprogramm freigeben?

LG

Alloziere doch den Speicher einfach in der Hauptfunktion und lass die Funktion nur in die Variablen, die du übergibst hineinschreiben.
Dann hast du das Problem mit der getrennten Anforderung und Freigabe nicht.

Oder eben nicht per return, sondern über Doppelpointer-Parameter ins main übertragen.

Soo ich hab nun eine Aufgabe zur Uebung von malloc/free und Pointern gemacht.
Die Aufgabenstellung:
a) Lesen Sie die Bauteile vom File und geben Sie in einer Tabelle aus. (Stückliste)
b) Lesen Sie die Bauteile vom File und geben Sie die Komplexen Widerstandswerte aus.
Verwenden Sie die Frequenzen 0, 100Hz, 1000Hz, 100000Hz.

Es funktioniert..., aber ich poste es mal hier und frage direkt: Ich geben ja alles immer im Unterprogramm(Funktion) aus. Ist das nach eurer Meinung in Ordnung? Was könnte man "besser" machen?

Die komplexen Widerstandswerte könnte ich in eine Struktur rein tun und dann diese Zurückgeben und im Main ausgeben..., aber ob das Sinn hat?

Ich willt halt nur mal fragen ob es so halbwegs passt was ich da gemacht habe .

Programm(es besteht aus 3 c-files und 2 h-files):

Code cpp:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311

#ifndef _rlc_h_ #define _rlc_h_ 1   #define MAXSTRLEN 50   struct complex_resistor {   double value;   double power_loss; }; typedef struct complex_resistor resistor;   struct complex_inductor {   double value;   double direct_current; }; typedef struct complex_inductor inductor;   struct complex_capaciator {   double value;   double proof_voltage; }; typedef struct complex_capaciator capaciator;   struct component_counts {   int r_count;   int l_count;   int c_count;   int ges_anz; }; typedef struct component_counts counts;   void stueckliste_print(resistor* component1, inductor* component2, capaciator* component3, counts rlc);   void compl_resistorValues(resistor* component1, inductor* component2, capaciator* component3, counts rlc);   #endif   //_____________   #include "rlc.h" #include <stdio.h>   void stueckliste_print(resistor* component1, inductor* component2, capaciator* component3, counts rlc) {   int x=0;     for(x=0; x<rlc.c_count; x++)   {     printf("|C   |%fF |Keramikondensator, Spannungsfestigkeit: %lfV    |\n",component3->value,component3->proof_voltage);     component3++;   }     for(x=0; x<rlc.l_count; x++)   {     printf("|L   |%fH |Spule, max. Gleichstrom: %lfA                    |\n",component2->value,component2->direct_current);     component2++;   }     for(x=0; x<rlc.r_count; x++)   {       printf("|R   |%0.2fOhm|Kohleschichtwiderstand max. Verlustleistung: %fW|\n",component1->value,component1->power_loss);       component1++;   }     printf("|____|__________|______________________________________________________|\n");   printf("|Name|Wert      |Bezeichnung                                           |\n"); }   void compl_resistorValues(resistor* component1, inductor* component2, capaciator* component3, counts rlc) {   int x=0;   int f=0;   int xr=0;   double xl=0;   double xc=0;   int eingabe=0;     printf("Mit welchen Frequenzen moechten Sie die komplexe Widerstandsberechnung durchgehen?\nTippen Sie 100, 1000 oder 100000 ein je nachdem was Sie wollen.\n");   scanf("%d",&eingabe);     switch(eingabe)   {     case 100:     f=100;     for(x=0; x<rlc.r_count; x++)     {       xr=component1->value;       component1++;       printf("Xr=%dOhm\n",xr);     }       for(x=0; x<rlc.l_count; x++)     {       xl=2*3.14*f*component2->value;       component2++;       printf("Xl=%0.15fOhm\n",xl);     }       for(x=0; x<rlc.c_count; x++)     {       xc=1/(2*3.14*f*component3->value);       component3++;       printf("Xc=%0.15fOhm\n",xc);     }     break;       case 1000:     f=1000;     for(x=0; x<rlc.r_count; x++)     {       xr=component1->value;       component1++;       printf("Xr=%dOhm\n",xr);     }       for(x=0; x<rlc.l_count; x++)     {       xl=2*3.14*f*component2->value;       component2++;       printf("Xl=%f0.15Ohm\n",xl);     }       for(x=0; x<rlc.c_count; x++)     {       xc=1/(2*3.14*f*component3->value);       component3++;       printf("Xc=%f0.15Ohm\n",xc);     }     break;       case 100000:     f=100000;     for(x=0; x<rlc.r_count; x++)     {       xr=component1->value;       component1++;       printf("Xr=%dOhm\n",xr);     }       for(x=0; x<rlc.l_count; x++)     {       xl=2*3.14*f*component2->value;       component2++;       printf("Xl=%0.15fOhm\n",xl);     }       for(x=0; x<rlc.c_count; x++)     {       xc=1/(2*3.14*f*component3->value);       component3++;       printf("Xc=%0.15fOhm\n",xc);     }     break;       default:     printf("Sie haben eine nicht vorhandene Frequenz eingegeben!\n");   } }   //______________________   #include "rlc.h" #ifndef _rlc_file_h_ #define _rlc_file_h_ 1   void c_read_file(char filename[], resistor* component1, inductor* component2, capaciator* component3);   counts c_componentCount(char filename[], counts rlc);   #endif   //_________   #include <stdio.h> #include <stdlib.h> #include "rlc.h" #include "rlc_file.h"     void c_read_file(char filename[], resistor* component1, inductor* component2, capaciator* component3) {   FILE* inFile = NULL;     char componentType='x';   double value=0.0;   double data=0.0;     inFile=fopen(filename,"r");   if(inFile != NULL)   {         if(component1 != NULL || component2 != NULL || component3 != NULL)     {       while(!feof(inFile))       {         fscanf(inFile,"%c, %lf, %lf\n",&componentType,&value,&data);           if(componentType == 'R')         {           component1->value=value;           component1->power_loss=data;           component1++;         }           if(componentType == 'L')         {           component2->value=value;           component2->direct_current=data;           component2++;         }           if(componentType == 'C')         {           component3->value=value;           component3->proof_voltage=data;           component3++;         }       }     }     else     {       printf("Memory allocation failure");     }       fclose(inFile);   }   else   {     printf("The File %s could not be opened",filename);   }     return(component1); }   counts c_componentCount(char filename[], counts rlc) {   int len =0;   char dummy[MAXSTRLEN];   FILE *inFile=NULL;     inFile=fopen(filename,"r");   if (inFile != NULL)   {     while(!feof(inFile))     {       fgets(dummy,MAXSTRLEN,inFile);       rlc.ges_anz++;             if(dummy[0] == 'R')       {         rlc.r_count++;       }         if(dummy[0] == 'L')       {         rlc.l_count++;       }         if(dummy[0] == 'C')       {         rlc.c_count++;       }     }     fclose(inFile);   }   else   {     printf("File %s could not be opened!\n",filename);   }     return(rlc); }   //__________   #include <stdio.h> #include <stdlib.h> #include "rlc.h" #include "rlc_file.h"   void main() {   char filename[MAXSTRLEN]="rlc.txt";   resistor* component1=NULL;   inductor* component2=NULL;   capaciator* component3=NULL;     counts rlc = {0,0,0,0};     rlc=c_componentCount(filename,rlc);     component1=(resistor *)malloc(sizeof(resistor)* rlc.r_count);   component2=(inductor *)malloc(sizeof(inductor)* rlc.l_count);   component3=(capaciator *)malloc(sizeof(capaciator)* rlc.c_count);     c_read_file(filename, component1, component2, component3);     stueckliste_print(component1,component2,component3,rlc);     compl_resistorValues(component1,component2,component3,rlc);       free(component1);   free(component2);   free(component3); }

Hi,

nur mal so nebenbei: Mit der Aussage das ein Array im Grunde auch ein Pointer ist, wäre ich vorsichtig Man kann ein Array, im Gegensatz zum Pointer, bspw. nicht referenzieren (Umkehroperation von Dereferenzieren). Der Grund ist eigtl. recht einfach: Ein Pointer ist selbst eine Variable welche wiederrum eine Adresse besitzt, das Array ist es nicht.

Gruß,
RedWing