✔ Dynamische Speicherverwaltung

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

C++: 
#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
 
Um antworten zu können musst du eingeloggt sein.

Neue Beiträge

Zurück