globale struktur (im modul definiert, und dennoch in der main() bekannt !!

[xdsmpDS]

sorry aber ich will immer noch das gleiche wie in meinem ersten post !

und ich hab echt keine ahnung was der kram auf http://c2.com/cgi-bin/wiki?PimplIdiom
mit meinem problem zu tun hat !
da steht irgendwas von klassen destruktoren und son kram !

ich hab aber keine klassen ! ich will auch keine !
ich will nur ne structur in nem modul definiert haben und in der main()
ne variable vom typ dieser struktur erstellen !

und es soll dan sowas gehn:
----------------------------
main()

meinestruktur feld[500];

dateieinlesen(feld);
feldsortieren(feld);
feldausgeben(feld);
----------------------------

funktionen und struktur definition sollen sich in nem modul befinden !!!

wenn ich die struktur aber nur in der moduldatei definiere, dann ist sie dem main unbekannt !

die struktur soll aber nicht aus der main()/main.cpp oder den headern der moduldateien zu erkennen sein !

[bozo]

dann kanst du nur einen pointer auf die struct oder einen index(handle) benutzen und in deinem modul eine funktion zur erzeugung und freigabe der instanz(en) erstellen und alle funktionen die mit diesen daten arbeiten bekommen den pointer oder index als parameter übergeben

[Maxi]

warum willst du sie eigentlich nicht in der Headerdatei definieren?
Du kannst auch versuchen in der HeaderDatei einmal

struct Meinestruct;

zu schreiben.
Und die inner Cpp dann richtig zu defnieren, wird aber wohl auch zu ungenügenden ERgebnuissen kommen

[Irgendwer]

Ich bin mir nicht ganz sicher wie es bei Structs geht aber bei einfachen build-in Variablen geht es folgendermassen:

Header:

extern int a;

cpp module:

int a;

cpp main:

int main()
{
    cout<<a<<endl;
}

I gehe davon aus dass to dein struct im Header declariren musst. Und die Instance als mit dem extern Keyword declariren und dan als ganz gewöhnliche die Instance in dem Module definieren. Das würde dann so aussehen:

Header:

struct A{
    int x;
};
extern A a;

cpp module:

A a;

cpp main:

int main()
{
    cout<<a.x<<endl;
}

Wie gesagt ungetestet!

Du kannst auch versuchen in der HeaderDatei einmal

struct Meinestruct;

zu schreiben.

Wenn man eine Structur so declariert reicht das noch nicht einmal eine Instance zu erschaffen! Legendlich Pointers sind möglich und auch dann kann man kein Member verändern.

[breakermaker.]

Hallo!

Meines wissens musst du die struct mit dem Schlüsselwort export deklarieren;
----------------------------------
Beispiel:

Export struct bsp
{
int a;
string b;
}
----------------------------------
Nun ist die Struktur soweit ich weiss auch der Main bekannt, auch wenn sie in ner .cpp datei liegt.

[breakermaker.]

achjaa... da habe ich ein semikolon vergessen; (ganz am ende)

[virtuell Realisticer]

Export? Das ist mir aber ganz neu.

Irgendwer hat schon gezeigt wie du das erreichen kannst, was du willst. Du
deklarierst in einer Headerdatei deine Struktur als extern und in einer
Implementationsdatei machst du dann die Strukturdeklaration.

@tobidope: Bitte doch etwas freundlicher, es war ja klar was gemeint war. wir
wolln doch net gleich jeden verkraulen.

mfg
v R

[Entyl_Sa]

Also extern verhilft einem nicht dazu eine Variable in deinem main anzulegen, sondern sagt nur das man eine extern schon angelegte Variable benutzen kann.

Wenn ich dein Problem richtig verstanden haben dann solltest du das volgendermassen machen:

f.h

struct Meinestruktur;

dateieinlesen(Meinestruktur[]);
feldsortieren(Meinestruktur[]);
feldausgeben(Meinestruktur[]);

Die Sache hier nennt sich Deklaration

f.cpp

struct Meinestruktur{
  int x;
  int y;
}

dateieinlesen(Meinestruktur[]){
  ...
}
feldsortieren(Meinestruktur[]){
  ...
}
feldausgeben(Meinestruktur[]){
  ...
}

Das ist die Definition, die wohl oder uebel ja irgendwo bekannt sein muss, so aber halt nicht in der .h, aber wenn du die irgendwann nur als Objekt File zur Verfuegung hast dann reicht es, und keiner sieht mehr deine Implementierung.

Dann kannst du:
main.cpp

#include "f.h"
int main(){

  meinestruktur feld[500];

  dateieinlesen(feld);
  feldsortieren(feld);
  feldausgeben(feld); 

  return 0;
}

Musst dann allerdings beim linken die Objekt oder die .cpp Datei von f angeben.

Gruß

Entyl Sa

[tobidope]

virtuell Realisticer schrieb:

Export? Das ist mir aber ganz neu.

Irgendwer hat schon gezeigt wie du das erreichen kannst, was du willst. Du
deklarierst in einer Headerdatei deine Struktur als extern und in einer
Implementationsdatei machst du dann die Strukturdeklaration.

@tobidope: Bitte doch etwas freundlicher, es war ja klar was gemeint war. wir
wolln doch net gleich jeden verkraulen.

mfg
v R

Nein, ich habe ihm die Lösung zu seinem Problem genannt. Anders geht es nicht. Ansonsten muss er die Programmiersprache wechseln. Er wird ein Struktur ohne Deklaration nicht verwenden können.

[bozo]

@Entyl_Sa
meinestruktur feld[500]; in der main geht so nicht,
da er ja die grösse der struct nicht kennt kann er dieses array nicht anlegen, als folge kommt ein kompilerfehler

möglich ist z.b. das folgende:

f.h:

#ifndef F_H
#define F_H

struct Meinestruktur; 

struct Meinestruktur* feldanlegen(int count);
void feldzerstoeren(struct Meinestruktur *feld);
void feldeinlesen(struct Meinestruktur *feld); 
void feldsortieren(struct Meinestruktur *feld); 
void feldausgeben(struct Meinestruktur *feld);

#endif

f.cpp:

#include "f.h"

struct Meinestruktur
{
	int x;
	int y;
};

struct Meinestruktur* feldanlegen(int count)
{
struct Meinestruktur *feld = 0;

	// ....
	return feld;
}

void feldzerstoeren(struct Meinestruktur *feld)
{
	// ....
}

void feldeinlesen(struct Meinestruktur *feld)
{
	// ....
}

void feldsortieren(struct Meinestruktur *feld)
{
	// ....
}

void feldausgeben(struct Meinestruktur *feld)
{
	// ....
}

main.cpp:

#include "f.h"

void main(void)
{
	struct Meinestruktur *feld;

	feld = feldanlegen(500);
	feldeinlesen(feld);
	feldsortieren(feld);
	feldausgeben(feld);
	feldzerstoeren(feld);
}

[tobidope]

Jetzt stellt sich nur noch eine Frage, was für einen Sinn hat das ganze?

[bozo]

kapselung

die implementierung dieses modules kann völlig unabhängig vom rest des programms verändert, erweitert, .... werden (solange sich die public funktionen nicht verändern), und dies ohne, das eine neu-kompilation der anderen module nötig ist

[bozo]

warum fragst du eigentlich?

dein genanntes "Pimpl Idiom" geht doch unter anderem auch in diese richtung

[tobidope]

bozo schrieb:

warum fragst du eigentlich?

dein genanntes "Pimpl Idiom" geht doch unter anderem auch in diese richtung

Deshalb wundere ich mich ja, es gibt funktionierende, dokumentierte und allgemein bekannte Alternativen. Wieso sollte man es anders machen?

[bozo]

@tobidope

diese methode ist doch auch funktionierend, dokumentiert und allgemein bekannt
und auch noch länger im gebrauch, da sie schon in c benutzt wurde

es gibt nun mal nicht nur eine möglichkeit etwas zu tun, oft sind es mehrere, z.b. kann man auch statt des pointers im obrigen beispiel einen index benutzen

warum man etwas anders machen sollte? weil es jenach genauem anwendungsfall einige unterschiede gibt, und nicht immer alle lösungsvarianten gleich gut passen

(
nicht so ernst zu nehmende antwort wäre ->

warum sollte man c++ nutzen, es gibt doch c, warum c, es gibt doch asm, .....
warum sollte man ...... (kannst etwas einsetzen), es gibt doch .....

)

[tobidope]

Aber wenn man C will, sollte man auch nicht unbedingt C++ nutzen. Berichtige mich, aber auf x und y kann er in obiem Beispiel nicht zugreifen, oder?

[bozo]

ja und nein
kommt drauf an von wo du diesen zugriff meinst:
in main.c kann man nicht auf die daten in der struct zugreifen, was ja auch der sinn für diese lösung ist, nur in f.cpp kann man auf die daten in der struct zugreifen, und nur dort gehört ja auch der direkte zugriff auf die daten in der struct hin

[Iregendwer]

kapselung

die implementierung dieses modules kann völlig unabhängig vom rest des programms verändert, erweitert, .... werden (solange sich die public funktionen nicht verändern), und dies ohne, das eine neu-kompilation der anderen module nötig ist

Das ist nicht Kapselung sondern Functionoverheat. Jedes mal wenn du einen Wert in der Structur verändern willst musst du eine ganze Funktion aufrufen. Ist dir es wirklich so wichtig die 2 int zu verkapseln?

und auch noch länger im gebrauch, da sie schon in c benutzt wurde

Die extern Methode ist eine C Methode die C++ compatible ist.

warum sollte man c++ nutzen, es gibt doch c, warum c, es gibt doch asm, .....
warum sollte man ...... (kannst etwas einsetzen), es gibt doch .....

Warum sollte man sich das Leben leicht machen, wenn es auch schwer geht?

in main.c kann man nicht auf die daten in der struct zugreifen, was ja auch der sinn für diese lösung ist, nur in f.cpp kann man auf die daten in der struct zugreifen, und nur dort gehört ja auch der direkte zugriff auf die daten in der struct hin

Vielleicht ist das die C Weise dies zu tun aber in C++ gibt es dafür private Member und Funktionen. Und da dies ein C++ Forum ist...

[bozo]

@Iregendwer
sorry, aber du hast es falsch verstanden

Das ist nicht Kapselung sondern Functionoverheat. Jedes mal wenn du einen Wert in der Structur verändern willst musst du eine ganze Funktion aufrufen. Ist dir es wirklich so wichtig die 2 int zu verkapseln?

diese zwei int's sind nur ein beispiel das Entyl_Sa benutzt hatte, und ich habs einfach übernommen,
die sind total unwichtig, waren nur sein beispiel,
es geht im grunde um einen abstrakten datentypen, der gekapselt werden soll, und für den kontextbezogene funktionen definiert werden

Die extern Methode ist eine C Methode die C++ compatible ist.

das mit dem extern ist aber etwas völlig anderes,
da wird eine variable global zugänglich gemacht, was man nun wirklich nur mit bedacht machen sollte, auch wollte er die struct auch erst in der main.cpp benutzen und kein festdefinierte variable in der moduldatei haben

Warum sollte man sich das Leben leicht machen, wenn es auch schwer geht?

habe ich denn etwas anderes geschrieben, nein

Vielleicht ist das die C Weise dies zu tun aber in C++ gibt es dafür private Member und Funktionen. Und da dies ein C++ Forum ist..

he?
was hat das damit zu tun, nichts
meine antwort passt einfach auf die in diesem thread gestellte frage und um die geht es ja wohl, es geht hier nicht um private member und funktionen, sondern darum das die struct nicht gloabal (in dem header) genau deklariert werden soll

[Irgendwer]

he?
was hat das damit zu tun, nichts
meine antwort passt einfach auf die in diesem thread gestellte frage und um die geht es ja wohl, es geht hier nicht um private member und funktionen, sondern darum das die struct nicht gloabal (in dem header) genau deklariert werden soll

Es geht darum ein struct in einem module zu definiren (definiren!=declariren) und es in einem anderen Module zugänglich zu machen, das ist für mich eindeutig die extern Methode, von Kapselung war nie die Rede.

Desweiteren wenn man in C++ Variablen einer struct für den Endprogrammirer unzugänglich machen will dann benutzt man private. Die Memberfunctionen werden in ein separates Modul gepackt. Und wenn man seine struct (was inzwischen schon eine class ist) verändern will dann verändert man sie im Header denn wenn man die neue benutzen will muss man eh den neuen Header benutzen.