struct getter und setter

sei:

struct A
{

double wert1;
double wert2;
const char* Name;
.....

};

Wie schreibe dafür einen Getter und Setter?

#include <stdio.h>

typedef struct A_Type { double wert; } A;
double getWert(A *a) { return a->wert; }
void setWert(A *a, double neuerWert) { a->wert = neuerWert; }

int main(void) {
	A a;
	setWert(&a, 1.0);
	printf("%f", getWert(&a));
}

5cript

Wozu überhaupt?
Gehörst zur Java Familie?

EDIT: no offense. Es ist ja nicht so als würde man damit was erreichen außer dass es nervig ist. (in C / POD-structs)

Hallo zusammen,

ich habe folgende:
Header Dateien:

typedef struct Mystruct Mystruct;

Mystruct *createMyStruct();
void  destroyMystruct(Mystruct *);

int getValueA(Mystruct*);
void setValueA(Mystruct*, int);

double getValueB(Mystruct*);
void setValueB(Mystruct*, double);

.........

void MeasurmentStart();

Source Dateien:

struct Mystruct
{
	int A;
	double B;

};

Mystruct *createMyStruct()
{
	return malloc(sizeof(Mystruct));
}

void  destroyMystruct(Mystruct *pointerStruct)
{
	delete pointerStruct;
}

int getValueA(Mystruct *pointerStruct)
{
	return pointerStruct->A;
}
void setValueA(Mystruct *pointerStruct, int dAValue)
{
		pointerStruct->A = dAValue;
}
.......
......
void MeasurmentStart()
{

	Mystruct * _myStruct = createMyStruct();
	....
	//Hier bekomme ich die Values von einem anderen Objekt
	Myclass myclass;
	.....
	setValueA(_myStruct, myClass.getMeasureA());
	setValueB(_myStruct, myClass.getMeasureB());
	........

}

Client:cpp

void main()
{
	MyStruct *mystruct;
	mystruct = createMyStruct();
	MeasurmentStart();
	std::cout << getValueA(mystruct) << cout ::endl;
}

--> Wie bekomme ich die Value von getValueA(mystruct)?

In welcher Sprache willst Du denn programmieren?

@ in C

Sisco_gast schrieb:

@ in C

Ok.

So wie es jetzt da steht ist's ein Mischmasch aus C und C++.

Ersetz das delete() durch free() .
MeasurementStart() mach so wenig Sinn.
Entweder die Funktion gibt was zurück, oder Du übergibst den Mystruct* als Argument (Gibt sicherlich noch zig andere Möglichkeiten...)

void MeasurmentStart(Mystruct *_myStruct){
    ....
    //Hier bekomme ich die Values von einem anderen Objekt
    Myclass myclass;
    .....
    setValueA(_myStruct, myClass.getMeasureA());
    setValueB(_myStruct, myClass.getMeasureB());
    ........
}

client.cpp
cout/endl sind c++

int main(void)
{
    MyStruct *mystruct = createMyStruct();
    MeasurmentStart(mystruct);
    printf("%d\n", getValueA(mystruct));
    destroyMystruct(mystruct);
}

So wie Du es jetzt hast machen sogar die getter und setter Sinn.
Opake Typen sieht man nicht so häufig in Anfängerfragen. Darauf war wohl Scripts Bemerkung bezogen.

Problem ist:
Beim Verlassen der Funktion "void MeasurmentStart(Mystruct * _myStruct)" ist das Objekt "_myStruct".

Deswegen bei diesem Aufruf:

int main(void)
{
    MyStruct *mystruct = createMyStruct();
    MeasurmentStart(mystruct);
    printf("%d\n", getValueA(mystruct));
    destroyMystruct(mystruct);
}

ist das Objekt getValue(mystruct) gleich 0.

Sisco_gast schrieb:

Beim Verlassen der Funktion "void MeasurmentStart(Mystruct * _myStruct)" ist das Objekt "_myStruct" [...] gleich 0.

Nur Du weisst, was Du in MeasurementStart() mit dem übergebenen Objekt machst.
Rufst Du darin ein destroyMystruct() auf?

Oder habe ich Dich mißverstanden?

Furble Wurble schrieb:

Sisco_gast schrieb:

Beim Verlassen der Funktion "void MeasurmentStart(Mystruct * _myStruct)" ist das Objekt "_myStruct" [...] gleich 0.

Nur Du weisst, was Du in MeasurementStart() mit dem übergebenen Objekt machst.
Rufst Du darin ein destroyMystruct() auf?

@nein

Sisco_gast schrieb:

Furble Wurble schrieb:

Sisco_gast schrieb:

Beim Verlassen der Funktion "void MeasurmentStart(Mystruct * _myStruct)" ist das Objekt "_myStruct" [...] gleich 0.

Nur Du weisst, was Du in MeasurementStart() mit dem übergebenen Objekt machst.
Rufst Du darin ein destroyMystruct() auf?

@nein

Dann ist irgendein anderer Fehler in Deinem Code. Aber mit den Informationen bis jetzt kann ich nicht helfen.
Zeig ein minimales Beispiel, das das Problem aufzeigt.

Wie man Probleme nachstellbar und nachvollziehbar macht

Was die Funktion: "void MeasurmentStart(Mystruct * _myStruct)" macht ist einfach gesagt Mystruct mit Werte zu füttern und deswegen habe ich die Getter und setter angewendet.

Sisco_gast schrieb:

Was die Funktion: "void MeasurmentStart(Mystruct * _myStruct)" macht ist einfach gesagt Mystruct mit Werte zu füttern und deswegen habe ich die Getter und setter angewendet.

Wenn ich ein minimales Beispiel erstelle funktioniert alles.
Irgendwo zerschießt Du Dir was.

#include <stdio.h>
#include <stdlib.h>

typedef struct foo{
  int a;
} foo;

foo* create_foo() { return malloc(sizeof(foo)); }
void destroy_foo(foo* f) { free(f); }

int get_a(const foo *f) { return f->a; }
void set_a(foo *f, int a) { f->a=a; }

void func(foo *f) { // Deine Funktion measurementStart
  set_a(f, 42);
}

int main(void){
  foo *f=create_foo();
  func(f);
  const int a = get_a(f);
  printf("%d\n", a); // 42
  destroy_foo(f);
}

Sisco_gast schrieb:

Was die Funktion: "void MeasurmentStart(Mystruct * _myStruct)" macht ist einfach gesagt Mystruct mit Werte zu füttern und deswegen habe ich die Getter und setter angewendet.

Wenn ich ein minimales Beispiel erstelle funktioniert alles.
Irgendwo zerschießt Du Dir was.

#include <stdio.h>
#include <stdlib.h>

typedef struct foo{
  int a;
} foo;

foo *create_foo() { return malloc(sizeof(foo)); }
void destroy_foo(foo *f) { free(f); }

int get_a(const foo *f) { return f->a; }
void set_a(foo *f, int a) { f->a=a; }

void func(foo *f) {
  set_a(f, 42);
}

int main(void){
  foo *f=create_foo();
  func(f);
  const int a = get_a(f);
  printf("%d\n", a);
  destroy_foo(f);
}

Hallo,

Zurück zu ProblemStellung:
Ich schreibe einen DLL Wrapper für einen C++ Code.
Dieses DLL Dateien muss nachher in LabVIEW importieren.
Um Dieses DLL in Labview zu importieren brauche ich dazu die notwendige Header File was auch Okay ist.

In dieses Header Datei ist einen Struct die ich leider nicht einfach in Labview importieren kann.
Aus diesem Grund habe ich gedacht an Setter und Getter einem Struct .