Stuktur i C++

google?!
Studera in dej på objektorienterad programmering (OOP), och lär dej tänket. Att tänka och arbeta objektorienterat underlättar så sjukt mycket då man börjar gå upp på mer komplexa program. I grund och botten, i OOP består allt av objekt/klasser, man kapslar in komplexa saker till en liten låda med ett par enkla handtag man kan komma åt utifrån. Genom det behöver man inte bry sej om vad som sker innuti. Ex. du lägger i ett mynt i en sedelautomat och sedan ser värdet på det, dvs. genom handtaget lägger du i myntet, och kan sedan genom ett annat handtag ta reda på värdet på myntet. All krånglig elektronik och sånt som läser av värdet på myntet slipper du bry dej om då du använder det. Visst låter det enkelt?

Annars, för att dela upp spelet i flera filer, så sök efter "include" i C++, ex. du skapar filen "spelare.cpp" (som bara har hand om självaste spelaren ex.), då tar du i main.cpp och skriver högst upp "#include "main.cpp"", så får main.cpp tillgång till allt i den filen, precis som om du skrivit alltet i main.cpp.

I enklast möjliga termer? Skapa en .h och en .cpp fil för varje "modul". I .h skriver du deklarationer av funktioner, datastrukturer, klasser och annat som ska delas. I .cpp skriver du definitionerna av det hela. Vill du använda någon från en del av programmet i en annan så inkluderar du .h filen som du inkluderar andra bibliotek (#include "gfx.h") och sedan kan du använda dig av de funktionerna efter att allt har länkats av kompilatorn. Om du sitter i en utvecklingsmiljö och jobbar brukar sådan sköta sig själv om man bara ser till att alla filerna ingår i samma projekt (eller motsvarande), kompilerar du manuellt måste du lägga till samtliga .cpp filer du vill länka ihop (typ g++ -o myprog 1.cpp 2.cpp 3.cpp ...).

Det finns en hel del annat att pilla med också för att få det att fungera som man vill, men börja lite med det ovan så har du i alla fall lärt dig allt du lär behöva för enklare program.

Ja och nej. De finns lokalt i filen, men du kan länka in dem i andra filern med extern-nyckelordet. Alltså, deklarera variabeln i en .cpp fil (aldrig en .h fil om du inte vet vad du gör), och deklarera dem sedan igen i andra .cpp filer fast använd "extern" framför (extern int myVar).
Allmänt så brukar det dock vara bäst att skicka parametrar mellan funktioner istället för att använda globala variabler.

Finns väl ingenting som säger att koden behöver vara sämre skriven om man inte använder OO? Man kan ju ha perfekt funktionsindelning och återanvändning av kod och fortfarande inte använda klasser och ha allt i samma fil. Blir ju dock jobbigt i stora projekt för läsbarheten, och kompileringstiden när man inte kan göra objekt-filer att återanvända för oförändrade delar.

Kan ju passa på att nämna att .cpp filer ska inte inkluderas, med undantag för om du använder templates då det måste göras. Inkludera annars endast headers och låt kompilatorn länka in .cpp filerna.

Det går, men är lite bökigt.

Program som skriver ut en 2D array med slumpat innehåll via funktionsanrop:

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

#define X_SIZE 4
#define Y_SIZE 5

void someFunction(int **array, int x, int y)
{
   int i, j;

   for (i = 0; i < x; i++) {
      for (j = 0; j < y; j++)
         printf("%3d", array[i][j]);
      printf("\n");
   }
}

int main()
{
   int **myArray;
   int i, j;

   myArray = new int*[X_SIZE];
   for (i = 0; i < X_SIZE; i++)
      myArray[i] = new int[Y_SIZE];

   srand(time(0));
   for (i = 0; i < X_SIZE; i++)
      for (j = 0; j < Y_SIZE; j++)
         myArray[i][j] = rand() % 100;

   someFunction(myArray, X_SIZE, Y_SIZE);

   return 0;
}

Fungerar dock bara om alla sekundära arrayer har samma storlek. Annars är det förmodligen enklast att slå in det hela i structar/klasser som innehåller dels all data, och dels storlekarna, för att slippa skicka in storlekarna manuellt.

En C array är bara en pekare, så det är ju bara att skicka pekaren.

När du skriver en array av arrayer, menar du då en fler dimensionell array? t.ex.:

int a[2][3] = {{1,2,3}, {4,5,6}};

eller en array av pekare till int, som i sig pekar på arrayer? t.ex.

int *b[2];
int c[] = {1,2,3};
int d[] = {4,5,6};
b[0] = c;
b[1] = d;

I det senare fallet använder du en funktion med en pekare till en pekare till en int som argument, t.ex.

void g(int **x)

I det första fallet är det lite bökigare. Du kan till exempel använda en funktion i stil med:
void f(int x[][3]) {...}
du måste dock vet hur många element den andra dimensionen har, så det blir lite begränsat.

i båda fallen kan du dock använda din array som vanligt.
cout << x[1][2];
fungerar utmärkt i båda fallen.

Jag föreslår dock att du kollar upp objekt-orienterad programmering och C++ standard bibliotek. Det kan underlätta mycket när man arbetar med mer komplexa data.

Om du läser lite bland best practices, så ska man inte inkludera cpp filer. Man ska bara inkludera header filer.