Array übergeben

Student90 · 13. November 2019 um 14:17

Liebe/-r Experte/-in,

ich bin gerade dabei Schiffe versenken in C zu programmieren. Dafür habe ich zunächst einmal sämtliche schleifen etc in die main geschrieben, um zu sehen, ob das ganze so funktioniert wie ich mir das gedacht habe. Das tut es!
Anschließend habe ich angefangen mit dem Erzeugen von Nebenfunktionen das ganze ein wenig übersichtlicher zu gestalten. Dabei ist folgendes Problem aufgetretten:
Nach der Eingabe der Schiffe (Nebenfunktion) funktioniert das ganze noch. Bei der Schussabfrage(Nebenfunktion) erkennt er jedoch nicht mehr, dass eine Schiff in das Array gesetzt wurde. Das Array habe ich dabei in einer eigenen Header-Datei definiert, welche sowohl in der main als auch in sämtlichen nebenfunktionen eingebunden ist.

Woran kann das liegen? Ich bin für jeden Ansatz dankbar. Da ich aber noch Anfänger bin traue ich mich noch nicht so ganz an Strukturen und Pointer ran… geht das auch ohne diese sachen zu lösen?
gern poste ich auch noch mal den quellcode falls das weiter hilft

vielen Dank im Vorraus
Student90

Subsurf · 13. November 2019 um 14:17

Hi,

vorweg wäre es wichtig zu wissen, ob du nun wirklich strikt in C schreibst, oder in C/C++. Mit C++ kannst du dir einige Sachen nämlich stark vereinfachen.

Bei programmiertechnischen Problemen ist helfen ohne den Quellcode zu kennen immer sehr schwierig, zumal ich mit deiner Beschreibung ehrlichgesagt noch nicht viel anfangen kann

Was ich aber schonmal sagen kann:
Wenn du C-Arrays übergeben willst, kommst du um Pointer nicht herum. Alle Arrayelemente werden im Speicher direkt hintereinander abgelegt. Der Variablennamen, den du für dein Array ausgesucht hast, ist im Grunde bloß ein Pointer auf das erste Element des Arrays, und mit dem Array-Index wanderst du dann von diesem Pointer aus entsprechend viele Bytes im Speicher weiter. Daher kannst du auch eine Zugriffsverletzung hervorrufen, in dem du einen höheren Index angibst, als Arrayelemente vorhanden sind.

Also:
Einmal den Quellcode posten, zumindest die Stellen, die dir Probleme bereiten, sofern der Rest dafür irrelevant ist.

MfG Subsurf

tuepp_4f8651 · 13. November 2019 um 14:17

Hallo Student 90,

ein Array stellt (wie übrigens auch eine Struktur) eine Ansammlung von Werten dar, die im Speicher hintereinander abgelegt werden. Um auf die Elemente zuzugreifen, merkt sich dein Programm immer den Anfang vom Array und zählt für alle anderen Elemente vom Anfang aus durch. Um das ganze abzukürzen: Indem du ein Array verwendest, arbeitest du bereits mit einem Pointer/Zeiger.

Beispiel:
int myArray[5] = { 0, 1, 2, 3, 4};
int *myPointer = myArray;

Ein Pointer ist eine Variable die für gewöhnlich auf etwas zeigt. Um zu zeigen dass sie gerade auf nichts zeigt, kann man sie auf NULL setzten: myPointer = NULL;

Möchte man ein Array an eine Funktion übergeben, übergibt man zwangsläufig den Pointer.

Kann so aussehen:

void main(){
/*initialisiert erstes Array-Element mit 0, alle anderen werden nun auf den Standartwert (ebenfalls 0) gesetzt.*/
int myArray[5] = {0};

myArray[0] = 1; //erstes Element beinhaltet nun den Wert 1
printFirstArrayElementA(myArray);
printFirstArrayElementA(myArray);
}

void printFirstArrayElementA(int *anArray){
printf(„Funktion A liefert: %i\n“, *(anArray+0));
}

void printFirstArrayElementB(int anArray[]){
printf(„Funktion B liefert: %i\n“, anArray[0]);
}

Die Funktionen printFirstArrayElementA und printFirstArrayElementB sind identisch und stellen lediglich verschiedene Schreibweisen dar.

Zusätzlicher Hinweis: Hier im Quelltext rufe ich erst die main() auf und schreibe dann die Funktionen - der Übersicht halber. Dies ist jedoch eigentlich C++. In C müssen die Funktionen immer oberhalb ihres Aufrufes bereits defeniert sein.

Keine Angst vor Zeigern, die sind auch nur Variablen, die halt auf was zeigen . Ja, man kann mit Zeigern ungewollt Speicher überschreiben wie zum Beispiel so:

myArray[5] = 1;

Letztes Array-Element eines Arrays mit 5 Elementen, hat den Index [4].

Unbekannten Speicher überschreiben kann böse sein, daher muss man hier aufpassen, was man tut. Das sollte dennoch kein Hindernis sein Zeiger (und damit Arrays) zu verwenden, denn darum wird man im maschinennahen C kaum kommen…

shuber2 · 13. November 2019 um 14:17

Hallo,

denkbar wäre folgendes Problem: das Array wird überall, wo die header Datei inkludiert wird, wiederholt definiert. Lösung: definiere das Array nur einmal in einer .cpp oder .c Datei. Wenn du auf das Array, als globale Variable, zugreifen willst, dann kannst du mit dem Schlüsselwort „extern“ in einer Header-Datei eine Deklaration vornehmen. Sei aber gewarnt: globale Variablen sind hässlich!

Grüße.

J_rgen_Braun · 13. November 2019 um 14:17

Hallo,

Wenn du eine Variable in einer Header-Datei definierst bekommst du jedes mal eine eigenständige Kopie der Variable, wenn die Headerdatei eingefügt wird.

Damit das nicht passiert musst du zum einen die Variable bzw. das Array im Headerfile als extern deklarieren (explizite deklaration), und zum anderen dann die eigentliche Deklaration in einem! Quellfile durchführen (implizite deklaration).
In der englischsprachigen Wikipedia gibt es einen ganz guten Artikel dazu: http://en.wikipedia.org/wiki/External_variable

Beispiel:

func1.h:
#ifndef __func1_h
#define __func1_h
extern int daten; /*explizite deklaration*/
void func1();
#endif

func1.c:
#include
#include „func.h“
int daten=10; /*implizite deklaration (hier mit inititalisierung)*/
void func1()
{ printf("%i\n", daten); }

main.c:
#include
#include „func.h“
int main(int argc, char *argv[])
{
func1();
daten=0;
func1();
return 0;
}

Markus_Kugler · 13. November 2019 um 14:17

Hallo Student90,

ich kann hier leider nur mit dem Quellcode weiterhelfen, da ich nicht weiss wie und wo die Variablen/Arrays deklariert sind. Gerne schaue ich noch ueber den Quellcode rueber und gebe die Hinweise.

Liebe Gruesse!

Bananae_Supremacy · 13. November 2019 um 14:17

Hallo Student90,

Du deutest an, dass du keine Pointer benutzt.
Ich vermute, dass du die Arrays den Funktionen „einfach so“ übergibst, was heißt, dass sie beim Funktionsaufruf kopiert werden und innerhalb der Funktion Veränderungen sich nur auf diese lokale Kopie auswirken.
Das bedeutet natürlich, dass die Änderungen anschließend weg sind.

Das Mittel der Wahl sind tatsächlich Referenzen (gibt es nur in C++, nicht in C) oder Pointer.
Ist eigentlich ein einfaches Prinzip, das ich bei Bedarf auch grundlegend erklären kann - ansonsten such dir doch Tutorials dazu raus, da gibt es einiges gutes zu.

Falls deine Frage damit noch nicht beantwortet ist, kannst du mir auch gerne mal deinen Quellcode zeigen, dann könnte ich dir genauer sagen was Sache ist.

Grüße

Student90 · 13. November 2019 um 14:17

Hey,

nein das ist nicht der Fall. Entschuldige meine schwammige Formulierung!
in der Header steht nur:

static int feld[11][27];

definiert wird das ganze dann, wie du bereits sagtes in einer Nebenfunktion.
ich hatte gehofft mit einer globalen Variablen um die Pointersache drum rum zu kommen. Die gefahren ienr globalen Variable bin ihc mir jedoch durchaus bewusst.

MfG
student90

Student90 · 13. November 2019 um 14:17

Hey!
Danke zunächst ein mal für die schnelle Antwort. Das Ganze sollte wirklich in C geschehen und nicht in C++.
Gern nehm ich dein Angebot an und kopiere dir mal die(meiner Meinung nach) relevanten Teile hier rein.
aber das wird wirklich etwas mehr… =)

Dazu dann vielleich auch noch einge erklärende Worte: Zunächst weiß ich, dass mein Programmierstil nicht besonders gut ist. Bitte reiß mir deswegen nicht gleich den Kopf ab. Wie gesagt bin mehr oder weniger blutiger Anfänger und freue mich, dass ich überhaupt soweit gekommen bin.
Die Eingabe besteht aus einer while-schleife und einen riesigen switch. Die Fälle sind jedoch alle gleich aufgebaut und ahst du einen verstanden (was dir nicht schwer fallen sollte ) hast du alle verstanden. Zum Ende lasse ich mir noch einmal das Feld ausgeben, um zu testen ob die SChiffe wirklich drin stehen. (Ja )
Gleiches mache ich als erstes in der Schussabfrage. Hier ist dann schon nichts mehr von Schiffen zu sehen.
Liegt das daran, dass das ganze bei der Eingabe nur lokal geschieht? (ich war der Meinung, wenn ich in eine Header-Datei mit einer Variablen einbinde, wirkt das wie eine globale Variable?
Die Feld-Header-Datei:

static int feld[11][27]; // Feld für die Eingabe der Boote

static int a\_feld[11][27]; // Feld für die Eingabe der Schüsse

Die main:

//eigene Headerdateien
#include "feldausgabe.h" // um die verschiedenen Felder auszugeben
#include "feld.h" //Feld als globale Variable definieren
#include "Schussabfrage.h" //Abfrage der Schüsse
#include "Schiffe.h" //Anzeigen der Auswahlmöglichkeiten
#include "Eingabe.h"
#include "start.h" //Ausgabe des Startbildschirms


int \_tmain(int argc, \_TCHAR\* argv[])
{ int x,y;

start(); //Ausgabe des Startbildschirms
feldausgabe(); //Feldausgabe
Schiffe (); //Ausgabe der Eingabemöglichkeiten
Eingabe ();
system("pause");
clear(); // Löschen des Bildschirms
feldausgabe2(); 
schussabfrage();//Abfrage der Schüsse

system("pause");

 return 0;
}

Die Eingabe-Funktion: (der Übersichtlichkeit habe ich nur die ersten beiden case gepostet)

#include "stdafx.h"
#include "stdlib.h"
#include "stdio.h"
#include "borland.h" 
#include "feld.h"
#include "lösche.h"
#include "Eingabe.h"
#include "feldausgabe.h"


int Eingabe()
{
 int welches=0, setzen=0;
 int posx1=0, posy1=0, hilf1=0, hilf2=0, hilf3=0;
 int x,y;
 do
 {
 gotoxy(35,10); //Springe rechts neben das Speilfeld
 printf("welches Schiffe mochten sie setzen?"); 
 scanf("%c",&hilf3);
 welches = (int) (hilf3-48);
 fflush(stdin); //Löschen des Eingabe Puffers
 gotoxy(35,11); //springe rechts neben den Bildschirm
 printf("welcher Buchstabe?"); // Uboot waagerecht 3 Felder´groß
 scanf("%c",&hilf1);
 fflush(stdin); //Löschen des Eingabe Puffers
 posx1 = (int) hilf1; //Umwandlung von char zu int
 gotoxy(35,12); // springe rechts neben das Spielfeld
 printf("Welche Nummer?");
 scanf("%c",&hilf2);
 posy1= (int) (hilf2-48);
 fflush(stdin); //Löschen des Eingabe Puffers

 switch(welches) // Schalter nach Auswahl des Bootes
 {
 case 1: if (feld [posx1-64][posy1+1] == '#' || //Uboot waagerecht 3 Felder 
 feld [posx1-63][posy1+1] == '#' || // Überprüfen ob eins der Ausgewählten Felder belegt ist
 feld [posx1-62][posy1+1] == '#') 
 {
 gotoxy(35,16);
 printf("Feld bereists belegt!! Neuses Boot und Feld aussuchen");
 }
 else if (posx1\>=65 && posx1=65 && posx1

Die Schussabfrage:


    
    #include "stdafx.h"
    #include "stdlib.h"
    #include "stdio.h"
    #include "borland.h" // für gotoxy-Befehle
    
    //eigene Headerdateien
    
    #include "feld.h" //Feld als globale Variable definieren
    #include "lösche2.h"
    
    
    int schussabfrage ()
    {
    int posx=0,posy=0,hilf=0,hilf2=0;
    int x,y;
    int weiter=0;
    float i=0, t=0;
    
    
    for (x=1; x=65 && posx=0 && posy
    
    
    FAlls du dir das wirklich angeguckt hast, wäre ich dir sehr dankbar!!!!Auch für tipps und Ansätze bin ich jederzeit offen!!
    MfG
    Student90

Student90 · 13. November 2019 um 14:17

Hey!
Danke zunächst ein mal für die schnelle Antwort.
Gern nehm ich dein Angebot an und kopiere dir mal die(meiner Meinung nach) relevanten Teile hier rein.
aber das wird wirklich etwas mehr… =)

Dazu dann vielleich auch noch einge erklärende Worte: Zunächst weiß ich, dass mein Programmierstil nicht besonders gut ist. Bitte reiß mir deswegen nicht gleich den Kopf ab. Wie gesagt bin mehr oder weniger blutiger Anfänger und freue mich, dass ich überhaupt soweit gekommen bin.
Die Eingabe besteht aus einer while-schleife und einen riesigen switch. Die Fälle sind jedoch alle gleich aufgebaut und ahst du einen verstanden (was dir nicht schwer fallen sollte ) hast du alle verstanden. Zum Ende lasse ich mir noch einmal das Feld ausgeben, um zu testen ob die SChiffe wirklich drin stehen. (Ja )
Gleiches mache ich als erstes in der Schussabfrage. Hier ist dann schon nichts mehr von Schiffen zu sehen.
Liegt das daran, dass das ganze bei der Eingabe nur lokal geschieht? (ich war der Meinung, wenn ich in eine Header-Datei mit einer Variablen einbinde, wirkt das wie eine globale Variable?
Die Feld-Header-Datei:

static int feld[11][27]; // Feld für die Eingabe der Boote

static int a\_feld[11][27]; // Feld für die Eingabe der Schüsse

Die main:

//eigene Headerdateien
#include "feldausgabe.h" // um die verschiedenen Felder auszugeben
#include "feld.h" //Feld als globale Variable definieren
#include "Schussabfrage.h" //Abfrage der Schüsse
#include "Schiffe.h" //Anzeigen der Auswahlmöglichkeiten
#include "Eingabe.h"
#include "start.h" //Ausgabe des Startbildschirms


int \_tmain(int argc, \_TCHAR\* argv[])
{ int x,y;

start(); //Ausgabe des Startbildschirms
feldausgabe(); //Feldausgabe
Schiffe (); //Ausgabe der Eingabemöglichkeiten
Eingabe ();
system("pause");
clear(); // Löschen des Bildschirms
feldausgabe2(); 
schussabfrage();//Abfrage der Schüsse

system("pause");

 return 0;
}

Die Eingabe-Funktion: (der Übersichtlichkeit habe ich nur die ersten beiden case gepostet)

#include "stdafx.h"
#include "stdlib.h"
#include "stdio.h"
#include "borland.h" 
#include "feld.h"
#include "lösche.h"
#include "Eingabe.h"
#include "feldausgabe.h"


int Eingabe()
{
 int welches=0, setzen=0;
 int posx1=0, posy1=0, hilf1=0, hilf2=0, hilf3=0;
 int x,y;
 do
 {
 gotoxy(35,10); //Springe rechts neben das Speilfeld
 printf("welches Schiffe mochten sie setzen?"); 
 scanf("%c",&hilf3);
 welches = (int) (hilf3-48);
 fflush(stdin); //Löschen des Eingabe Puffers
 gotoxy(35,11); //springe rechts neben den Bildschirm
 printf("welcher Buchstabe?"); // Uboot waagerecht 3 Felder´groß
 scanf("%c",&hilf1);
 fflush(stdin); //Löschen des Eingabe Puffers
 posx1 = (int) hilf1; //Umwandlung von char zu int
 gotoxy(35,12); // springe rechts neben das Spielfeld
 printf("Welche Nummer?");
 scanf("%c",&hilf2);
 posy1= (int) (hilf2-48);
 fflush(stdin); //Löschen des Eingabe Puffers

 switch(welches) // Schalter nach Auswahl des Bootes
 {
 case 1: if (feld [posx1-64][posy1+1] == '#' || //Uboot waagerecht 3 Felder 
 feld [posx1-63][posy1+1] == '#' || // Überprüfen ob eins der Ausgewählten Felder belegt ist
 feld [posx1-62][posy1+1] == '#') 
 {
 gotoxy(35,16);
 printf("Feld bereists belegt!! Neuses Boot und Feld aussuchen");
 }
 else if (posx1\>=65 && posx1=65 && posx1

Die Schussabfrage:


    
    #include "stdafx.h"
    #include "stdlib.h"
    #include "stdio.h"
    #include "borland.h" // für gotoxy-Befehle
    
    //eigene Headerdateien
    
    #include "feld.h" //Feld als globale Variable definieren
    #include "lösche2.h"
    
    
    int schussabfrage ()
    {
    int posx=0,posy=0,hilf=0,hilf2=0;
    int x,y;
    int weiter=0;
    float i=0, t=0;
    
    
    for (x=1; x=65 && posx=0 && posy
    
    
    FAlls du dir das wirklich angeguckt hast, wäre ich dir sehr dankbar!!!!Auch für tipps und Ansätze bin ich jederzeit offen!!
    MfG
    Student90
    
    
    >

shuber2 · 13. November 2019 um 14:17

in der Header steht nur:

static int feld[11][27];

definiert wird das ganze dann, wie du bereits sagtes in einer
Nebenfunktion.

Ich kann mit dieser Beischreibung leider nichts anfangen, weil ich nicht weiß, was das „ganze“ ist. Übrigens, wenn a.cpp und b.cpp jeweils das Header file inkludieren, dann wäre das so, als ob du in a.cpp und in b.cpp jeweils ‚static int feld[11][27]‘ geschrieben hättest.

Markus_Kugler · 13. November 2019 um 14:17

Hallo -

ich denke Dein Problem liegt an der statischen Felddefinition in der Header-Datei. Ich gehe von der Struktur davon aus das Du verschiedene Quelldateien hast, eine „feld.h“ hast und die Dateien dann verlinkst. Dadurch das die Felder ‚static‘ sind, geht das auch gut, sind damit aber auch nur lokal-global (global in jeder Datei aber alles ist ein unterschiedlicher eigener Speicher). Versuche es so:

Nehme die definition von feld und a_feld aus der Header Datei „feld.h“ heraus.
Zwischen _tmain() und den Includes schreibe:
int feld[11][27];
int a_feld[11][27];
Damit die anderen Teile auch feld und a_feld kennen (und damit das gleiche mit dem gleichen Speicher) kommt direkt nach den includes in den anderen Dateien:
extern int feld[][];
extern int a_feld[][];
(mit dieser Syntax bin ich nicht ganz sicher etwas experimentieren mit den Klammern… das ‚extern‘ zwingt den Compiler/Linker woanders nach der definition von feld und a_feld zu suchen und das ist dann nur in main…)

Ich hoffe ich konnte Dir damit weiterhelfen, kannst Dich gerne nochmal melden falls Du dazu noch eine Frage hast.

Als Vorschlag: Ich programmiere recht grosse Anwendungen in C, die relativ schnell sein sollen und aber auch wartbar bleiben sollen. Ich gehe dazu ueber Ansaetze aus der OO Programmierung zu verwenden. Hier haettest Du das feld und a_feld in einer eigenen Datei statisch definiert und der Zugriff geschieht nur ueber Funktionen. Aus Sicherheitsgruenden (integritaet von feld und a_feld) kennen die anderen Programmteile feld nicht (Zum Beispiel hast Du funktionen wie ‚setze Schiff‘, ‚Positionsabfrage‘, ‚loesche Schiff‘… aber sonst kann keiner auf feld zugreifen).

Viele Gruesse und viel Spass dabei noch…

Thomas_Block · 13. November 2019 um 14:17

Hallo,
ohne Quelltext ist das schwierig zu analysieren.
Gruß Thomas

PitEo · 13. November 2019 um 14:17

Ich vermute mal, dass das Array zweimal definiert ist, und dass das Eintragen auf die eine Instanz und das Abfragen auf die andere losgeht.

Eine Header-Datei, die mit #include eingezogen wird ist nichts anderes, als wenn der Text der Datei an der Stelle stünde, wo die include-Anweisung steht. Wenn also in beiden C-Dateien die gleiche Header-Datei includiert wird, hat man das Array zwei Mal. Eigentlich sollte dann der Linker einen Fehler melden.

Korrekt müsste das Array in einer Datei mit (z.B.)
int Array [20];
definiert werden und in der Header-Datei als
extern int Array [20];
deklariert werden. Dann sollte es funktionieren.
Wenn nicht, bitte Quellcode senden.
Gruß Pit. (Eo steht übrigens für Esperanto)

Mark_Rohrbacher · 13. November 2019 um 14:17

Hallo Student90,

ich bin mir nicht ganz sicher, was das Problem ist, aber ich denke, dass das Array gewissermassen „pro c-Datei“ genutzt wird.

Versuch mal, in der h-Datei das Array als „extern“ zu definieren und das Array selbst in einer C-Datei anzulegen:

spielfeld.h:
#ifndef __SPIELFELD_H__
#define __SPIELFELD_H__
extern char spielfeld[10][10];
void init_spielfeld();
#endif // __SPIELFELD_H__

spielfeld.c:
#include „spielfeld.h“

char spielfeld[10][10];
void init_spielfeld()
{
…
}

Ansonsten einfach mal den Quellcode posten.
PS: Schiffe versenken ist ein prima Versuchskaninchen, um mal mit Pointern zu üben

Gruß

Mark

Joe_7b40bf · 13. November 2019 um 14:17

Na ja, ohne Zeiger und Strukturen macht C wenig Sinn Dann musst Du alle Daten global machen und das macht den Code unübersichtlich und fehleranfällig.

Ohne den Code gesehen zu haben: vmtl. hast Du der Funktion, die das Array manipulieren soll, nur eine Kopie des Werts der im Arrays verändert werden soll, übergeben. Somit wird nicht der Inhalt des Arrays manipuliert sondern nur die Kopie verändert. Damit in einer Funktion der Inhalt des Arrays verändert wird muss der Funktion die Adresse des Arrays, also ein Zeiger, übergeben werden.

Am besten Debugausgaben einbauen oder gleich mit dem Debugger sich den Inhalt des Arrays anzeigen lassen.

Viel Erfolg

Anonym_7274eeea5be8 · 13. November 2019 um 14:17

Hallo Student90,

den großem Monolithen in kleine Module aufzuteilen ist goldrichtig! Immer in kleinen Einheiten denken und arbeiten! Das ist, wie du selbst sagst, übersichtlicher. Die einzelnen Funktionen können aber auch viel einfacher getestet werden.

Für Schiffeversenken brauchst du natürlich ein Array (auch noch ein zweidimensionales!), und damit musst du dich auch mit Pointers auseinandersetzen. Anders geht es nicht.

Daten in einer Header-Datei zu definieren ist grundsätzlich ein Fehler. („Definitonen“ mit #define sind keine C-Daten-Definitionen.) In der H-Datei dürfen (globale) Daten nur deklariert werden. Durch die Definition des Array in der H-Datei erhältst du in jeder Datei, in der du die Header-Datei einbindest, ein neues Array! Definition bedeutet Erzeugung! Die Deklaration dagegen teilt dem Compiler nur mit, dass irgendwo das Array einmal definiert, also erzeugt ist. So in etwa:

schiffeversenken.h:

 #define DIM 15 // Breite und Höhe des Feldes
 extern char[DIM][] feld; // Deklaration des Feldes

main.c:

 #include "schiffeversenken.h"
 char[DIM][DIM] feld; // Definition des Feldes

Mein Empfehlung zum C-Lernen ist nach wie vor das Buch Programmieren in C von Brian Kernighan und Dennis Ritchie aus dem Hanser Verlag. Kostet gebraucht 11 Euro. Beste Frust-Vermeidung.

Alles Gute,

Tosta

Raymond_Sommer_e78d42 · 13. November 2019 um 14:17

Hallo

das funktioniert über die Header-Datei nicht. Du musst folgendermassen vorgehen:

Felddeklaration aus der Header-Datei entfernen
Schreibe die Feldeklaration vor (!) die main in die Quellcodedatei des Hauptprogrammes, z.B.
int feld[100][100];
int main() { …
Schreibe in allen anderen Quellcodedateien, in welchen das Feld benötigt wird ganz an den Anfang, d.h. vor (!) die Funktionen, Folgemdes:
extern int feld[100][100];

Dann sollte es klappen. Viel Erfolg

Gruss

Student90 · 13. November 2019 um 14:17

Hey,

tut mir leid, dass es etwas gedauert hat, aber ich dachte mir lieber spät als nie…

in diesen Sinne möchte ich mich bei dir recht herzlich bedanken!!! Mit der extern-Schreibweise hat das ganze genau so funktioniert wie es soll! DANKE für deine Hilfe

Beste Grüße
Martin

Hans_Streibel · 13. November 2019 um 14:17

Hallo lieber Student90,

ist schon etwas her, dass du die Frage stelltest.
Sorry, ich hatte keine Zeit - und dann ist deine Email etwas
in Vergessenheit geraten.

Besteht das Problem mit den Arrays immer noch?
Wenn ja, dann schick mir doch bitte einmal die
relevanten Sourcen zu. Die, wo du die Arrays uebergibst.
Mit Header-Dateien. Und sag mir bitte, bei welcher
Funktion es nicht geht.

Ohne Sourcen kann ich auf die Entfernung nicht viel sagen.

Da
ich aber noch Anfänger bin traue ich mich noch nicht so ganz
an Strukturen und Pointer ran… geht das auch ohne diese
sachen zu lösen?

Hmm, der Arrayname alleine ist schon ein Pointer auf
das erste Element des Arrays. Arrays und Pointer sind also
sehr miteinander verwandt.

Sehr schoen erklaert finde ich das Ganze in der C-Bibel:
Kernighan/Ritchie:
Programmieren in C

Hier ist die deutsche Uebersetzung sogar ausnahmsweise
einmal besser als das Original.

Viele Gruesse

Hans