pointer/malloc/free

Hallo!

Ich habe 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):

#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);
}

mfg

kannst du nicht aus den 9 schleifen im switch 3 machen? dann kommen auch die fehler raus, falls da überhaupt welche sind

Naja, wie ich oben gesagt hab es funktioniert. Ich will nur wissen ob das in Ordnung ist die Ergebnise einfach im Unterprogramm auszugeben.

ich habs nicht getestet! behaupte aber, dass da ein fehler im format string ist. "Xc=%f0.15Ohm\n"

Mh ich könnte nichts erkenne was da falsch sein könnte. Meinst du das %f? Müsste ja so passen oder?

was macht eig. der 'counts rlc' parameter der c_componentCount funktion?

counts rlc ist eine struktur, darin steht die Anzahl der Widerstände, Spulen und Kondensatoren. diese werden dann halt dann in der for für die ausgabe verwendet

Wutz

Schrott ist:

- void main
- return-Wert bei der void c_read_file
- feof-Abfrage statt fscanf/fgets-Returnwert Auswertung
- switch: die case-Zweige sind im Wesentlichen kopierter/gleicher Code
- bei defines verwendet man üblichweise ausschließlich Großbuchstaben
- du löscht den Eingabepuffer nicht nach Nutzereingaben
- du wertest scanf-Returnwert nicht aus
- die eigenen Namenskonventionen bei Typen und Variablen würde ich unterschiedlich wählen
- Variablen, die nicht geändert werden, sollte man "const" spendieren (gilt auch bei Funktionsparametern)
- ...

Liest du eigentlich Compilerwarnungen?

Danke dir!

Aber wie ist das jetzt mit dem Ausgeben im Unterprogramm/Funktion? machen oder nicht machen?

Und wegen dem switch, ja es steht 3mal fast das selbe drinnen, wie könnte ich das den vereinfachen?

Zu den Warnungen: Ich habe irgendwie keine Warnungen beim "Starten ohne Debugging"

Wutz

- ja, geht so
- gleiche Funktionalitäten gehören in eine eigene Funktion gekapselt
- ich sprach von Compilerwarnungen, nicht von Laufzeitwarnungen