Struct über Zeiger füllen

Mechanics

Es ist doch klar was er meint...

hustbaer

Mechanics schrieb:

Es ist doch klar was er meint...

Er ist aber er selber, und er will eine Erklärung (Korrektur: Beispiel, zur Verdeutlichung) von dir was du meinst *g*

Wutz

typedef struct {
int wert1;
int wert2;
} Messwert; /* deutsches sz in Namen ist nicht erlaubt */

...

int main()
{
  Messwert messwert[10]={0}; /* Definition eines Array mit 10 Elementen vom Typ Messwert und alles 0 initialisiert */
  ...

  messwert[0].wert1 = 1;
  messwert[0].wert2 = 2;
  ...
  messwert[9].wert1 = 9;
  messwert[9].wert2 = 10;
  ...
}

Patrick_C64

( Wutz war schneller )

Mal neben der heissen Luft die hier produziert wird, ein Versuch Dir auf die Sprünge zu helfen!

// Das ganze ohne Struct!
// Struct brauchste auch nicht !!!,
// ausser es kommen Infos zu den Sensoren oder 
// Zeit und Datum hinzu zu den Messwerten!
// dann würde ich aber ein Array für das Struct
// erstellen. 
// Also ein Struct (sMesswert) entsprechend den Anforderungen
// erstellen und dann Anstatt int messwert[] sMesswert messwert[] 
//
// Man muss aber kein Array mit N Messwerten erstellen
// das kann man dann mit Pointern und malloc realisieren.
// oder das ganze gleich in eine Datei schreiben oder was auch
// immer dafür gibt es viele Lösungsansätze.

#define _MW_MAX_ (100)
static int messwert[_MW_MAX_]; // Array zum Speichern der Werte!

Loop () {

static int current      = 0;
static int Currenttime  = 0;
static int LastTime     = 0;

CurrentTime = GetTime();      

if ( current < _MW_MAX )
  if( (CurrentTime - LastTime) > 30) {
    messwert[current] = ReadSensor();
    current++;

  LastTime = CurrentTime;
  }

}

// hoffe hab dein Anliegen richtig interpretiert (denke schon!)
// und das dir der kleine pseudocode ein wenig auf die Sprünge hilft!
// ansonsten mit memcpy () für das Kopieren von Daten.
// Du hast aber nur einen INT und da würde das keinen Sinn machen!
// Wenn du Struct nach Struct kopieren willst wäre das Sinnvoll!
// Oder du verweist direkt auf das Struct per Pointer und addierst 
// so dazu das du zb. deine Zieladresse Struct.messwert1 ansprechen tust
// das wäre aber hier nicht Sinnvoll! (siehe Pointer-Aritmethmetik)
//
// Wenn du das Struct nutzen MUSST! Dann designe es so
// das du in diesem ein Array hast der die Messwerte 0-n speichert!
// Denn wenn jetzt dein Auftraggeber kommt und sagt 10 Messwerte
// sind zu wenig wir brauchen 1000 ! *GRIEEEEN
// dann viel Spass beim schreiben von ....
//
// struct Messwert {
// int wert1;
// int wert2;
// int wert3;
// ...
// ...
// int wert1000;
// }
//
// Da wäre es doch besser WENN
//
// #define _MW_MAX_ (1000)
// struct Messwerte {
// int messung[_MW_MAX_];  // Das geht nur solange eine Messung keine
// }                       // weiteren Parameter hat !!!!!!
// 
// Wobei es relativ Sinnfrei ist ein Struct für die aufnahme eines Int zu 
// erstellen, da kann man gleich in ein Int schreiben! 
//
// Man sollte damit rechnen das noch mehr Werte kommen also Zeit und Datum
// der Messung, deswegen mache für eine Messung ein Struct und pack das in
// ein Array.
//
// typedef struct {
//   int mwert;
//   int sensorID;
//   time mtime;
//   date mdate; 
// } Messung;
//
// Messung messwert[_MW_MAX_];
//
// messwert[10].mwert = 007;
// messwert[10].sensorID = 0815;
// usw. usf.

Wie gesagt gibt etliche Möglichkeiten, wichtig ist ja erstmal das du überhaupt einen für dich (für das Problem!!) annehmbaren Lösungsansatz hast oder ein Paar Ideen dazu bekommtst.

Ist zwar alles nur Pseudocode sollte Dir aber ein wenig auf die Sprünge helfen.

mfg.

chris74

Hallo Patrick_C64, danke für deine Beispiele !
Ich habe mich nun doch für einen Struct entschieden in den so wie du auch schon gesagt hast auch datum und zeit steht.

Nun ist mir aber nicht klar wie ich einen Zeiger schreibe der mein Wert in das Struct schreibt. Wie sagt man dem Zeiger daß er eine Stelle weiter rückt?

Währe nett wenn du noch ein Beispiel dafür hast.

Swordfish

#include <stdlib.h>

struct foo_t
{
	int bar;
};

int main( void )
{
	struct foo_t foo[ 10 ] = { 0 };

	size_t i = 0;
	struct foo_t *p = NULL;

	// mit Index:
	for( i = 0; i < sizeof( foo ) / sizeof( foo[ 0 ] ); ++i ) {

		foo[ i ].bar = 815;
	}

	// mit Pointer
	for( p = foo; p - foo < sizeof( foo ) / sizeof( foo[ 0 ] ); ++p ) {

		p->bar = 3;
	}
}

OT: Wenn ich heute noch irgendwo "erstellen" für irgendwas lese, das einen Namen hat, hat mein Tisch die nächsten Bisspuren ...

chris74 schrieb:

Nun ist mir aber nicht klar wie ich einen Zeiger schreibe der mein Wert in das Struct schreibt.

zeiger->mwert = 12345;

chris74 schrieb:

Wie sagt man dem Zeiger daß er eine Stelle weiter rückt?

zeiger = zeiger + 1;
//oder
zeiger += 1;
//oder
++zeiger;
//oder
zeiger++;

Mechanics

hustbaer schrieb:

Mechanics schrieb:

Es ist doch klar was er meint...

Er ist aber er selber, und er will eine Erklärung (Korrektur: Beispiel, zur Verdeutlichung) von dir was du meinst *g*

Oops... Sorry, das hab ich jetzt voll übersehen.

Patrick_C64

Hallo Chris74,

DirkB hat Dir ja schon ein Beispiel aufgezeigt. Als Stichwort dazu schaue Dir bitte einmal Pointeraritmethik an.

Und überdenke vllt. noch einmal ob ein Zugriff über Adressen (bzw. Pointer) in diesem Fall nötig bzw. angebracht ist! Pointer sind keine Zauberei und auch garnicht alzu schwer zu verstehen, aber bei falscher Handhabung können die undefiniertes Verhalten verursachen oder Speicherlöcher sog. Memoryleaks "reissen". Soll heissen wenn die nicht nötig sind sollte man andere Lösungsansätze vorziehen.

Du kannst einzelne Attribute eines Structs auch über einen Punktoperator ansprechen, das ist 1. Sicherer und 2. für deinen Fall auch besser bzw. komfortabler.

Wenn du ein Pointer auf ein Struct hast dann kannst du die einzelnen Attribute auch über den "->" Pfeiloperator ansprechen. Pointeraritmethik wäre in diesem Fall Overhead ^10 :)! Die würde ich für meinen Teil ehh nur nutzen wenn ich Speicher manuel alloziere je nach Fall und Bedarf.

Nehmen wir an du hast jetzt dein fertiges Struct für die Messungen weisst aber nicht wie viele du anlegen möchtest, dann allozierst du Speicher für n "Instanzen" des Structs. Oder erweiterst deinen Speicherbereich je nach Bedarf dann musst bzw. kannst du über Pointeraritmethik oder [] auf einzelne Messungen zugreifen. Auf die Elemente der Messungen wiederum kannst du dann je nach Cast über Punkt oder Pfeiloperator zugreifen.

Schau Dir dazu mal ein Paar sachen an, arbeite erstmal zb. an ganz kleinen Beispielen also fernab von deiner Messungsgeschichte um da Verständniss für zu bekommen, also erst ein paar primitive Datentypen und dann mit Structs. Dann mehrdimensional usw.

Weisst du aber wieviele Messungen du hast kannst/solltest du auch ein Array nutzen. Wobei wenn die Messungen eh extern später verarbeitet werden sollen/müssen kann man die auch gleich in eine Datei schreiben.

Danke auch für dein nettes Feedback,toi toi toi und Happy Coding!

mfg. Patrick

OT: Am liebsten würde ich ja jetzt noch ein paar INTs erstellen aber aus Rücksicht vor wehrlosen Tischen und Zähnen lassen wir das mal besser. *GRIEEN

(Deklaration und/oder Definition sind schon angebrachter als Erstellen, aber meine Güte man muss ja nicht übertreiben, das hätte vllt. sogar auch zur Verwirrung führen können wenn man nicht weiss was damit gemeint ist, da ist Erstellen m.E. schon die bessere Wortwahl auch wenn Fachlich vllt. unpassend!)

Swordfish

OT:

Patrick_C64 schrieb:

[...] auch wenn Fachlich vllt. unpassend!)

Mir geht's garnicht um "fachlich richtig" - mich kotzt's nur an, daß heutzutage /alles/, Grafiken, Websites, ... Spiele (<- !! Da gibt's dann Fragen à la "Mit welchem Programmierprogramm kann ich denn ein Spiel erstellen?") ... E R S T E L L T wird. Am besten aus dem Nichts: "Wo muss ich klicken?", "Hab' ich gemacht, geht nicht!!", ...