Sammansatta datatyper

Scoping

Definitionen på en struct har även ett scope, d.v.s. det område i programmet där den är definierad. Man kan definiera en struct nästan var som helst i ett C++-program, och det ger vissa scoping-regler. En struct som är definierad inom en viss funktion kan endast användas inom den funktionen. Vill man att datatypen skall kunna användas av alla delar av ett program bör den placeras externt, d.v.s. utanför alla funktioner i början av programmet.

struct Kund {
  string Namn;
  string Adress;
};

void foobar () {
  // lokal definition, kan endast användas i denna funktion
  struct Rakning {
    string Vara;
    int Pris;
  }

  // definiera variabler av datatyper
  Kund K1;
  Rakning Spikar, Hammare;
  ...
}

int main () {
  // definiera variabler av datatyper
  Kund Foo, Bar;
  ...
}
  

I exemplet ovan innehåller funktionen foobar en egen lokal definition på en struct. Denna kan endast användas inom foobar(), eftersom dess scope inte sträcker sig till main(). Däremot kan Kund användas överallt i programmet, eftersom den är definierad utanför (och före) alla funktioner.

Accessera medlemmar

Vi har ingen glädje av struct:s om vi inte kan accessera datamedlemmar i en struct. Det är dock mycket enkelt att accessera och ändra data. Det görs genom att man avrefererar datamedlemmen med en punkt (.). För att t.ex. ge en ny telefonnummer åt medlemmen Telefonnummer i variabeln Ingvar gör man så här:

Person Ingvar;
Ingvar.Telefonnummer = 5556789;

Alla datamedlemmar kan acesseras med en punkt. Efter denna avreferering kan de användas precis på samma sätt som datatypen normalt kan användas. I exemplet ovan kan Ingvar.Telefonnummer användas precis som en normal int.

Då man skapar nya variabler av en struct kanske man vill direkt ge ett värde åt alla medlemmar. Då kan man göra enligt följande:

Person Ingvar = { "Ingvar Infåit", "DataCity", 5551234 };

Värdena sätts innanför { och }; i exakt den ordning som de givits då datatypen Person definierats. Första värdet ges åt första medlemmen o.s.v. Vill man ge ett värde direkt är detta den enda möjligheten. Följande är inte tillåtet, och kommer att resultera i ett kompileringsfel:

Person Ingvar;
Ingvar = { "Ingvar Infåit", "DataCity", 5551234 };

Jämföra och tilldela

Att jämföra och tilldela struct:s kan vara lite knepigt. Tilldelning enligt följande är inte alltid möjlig:

Person Ingvar = { "Ingvar Infåit", "DataCity", 5551234 };
Person Elsa = Ingvar;

Det hela beror på innehållet i struct:en. Det som sker i en tilldelning som denna är att kompilatorn kommer att se till att Elsa tilldelas alla medlemmar från Ingvar. Ovanstående i princip ekvivalent med följande:

Person Ingvar = { "Ingvar Infåit", "DataCity", 5551234 };
Person Elsa;
Elsa.Namn = Ingvar.Namn;
Elsa.Adress = Ingvar.Adress;
Elsa.Telefonnummer = Ingvar.Telefonnummer;

För vårt exempel fungerar tilldelningen fint, eftersom tilldelningsoperatorn = är definierad för alla datatyper som används i Person. I alla sammanhang är det inte så, speciellt om olika främmande struct:s används. Om = inte är definierad får man i vissa fall resultat som inte är önskvärda. Man kan då explicit definiera en =-operator för struct:en, men i sådana fall är det i alla fall mera praktiskt att använda en klass (se Kapitel 14). Så länge som man endast använder primitiva datatyper i en struct kan man använda normal tilldelning.

Jämförelse av sammansatta dattyper är ännu svårare. Där kan man i normala fall aldrig direkt använda sig av operatorn == för att åstadkomma en jämförelse, utan man måste manuellt jämföra varje medlem. Detta kan vara ganska arbetsdrygt och fult om det är frågan om en stor datatyp. I kapitlet Kapitel 21 redogörs för hur man kan definiera operatorn == för klasser, men det samma kan även appliceras på struct:ar.

Sammansatta datyper som parametrar

Man kan givetvis skicka sammansatta datatyper som parametrar till funktioner. De fungerar precis som vilka datatyper som helst. Vill man kunna ändra på en struct som skickats som parameter bör man skicka en pekare eller använda referensparametrar (&). Exemplet nedan läser in en Produkt och skriver ut denna:

#include <iostream>
#include <string>

struct Produkt {
  string Namn;
  float  Pris;
  int    Antal;
};

void nyProdukt (Produkt & P) {
  // läs in data i produktens medlemmar
  cout << "Namn : ";
  cin >> P.Namn;
  cout << "Pris : ";
  cin >> P.Pris;
  cout << "Antal: ";
  cin >> P.Antal;
}

void skrivUt (Produkt * P) {
  // skriv ut info om produkten
  cout << endl;
  cout << "Information om produkt: " << P->Namn << endl;
  cout << "  pris:  " << (*P).Pris << endl;
  cout << "  antal: " << P->Antal << endl;
}

int main () {

  Produkt Ny;

  // läs in en produkt
  nyProdukt ( Ny );

  // skriv ut på skärmen
  skrivUt ( &Ny );
}

Körning av programmet kan t.ex. se ut på följande sätt:

% Struct4
Namn : C++-kompilator
Pris : 19.90
Antal: 3

Information om produkt: 
  namn:  C++-kompilator
  pris:  19.9
  antal: 3
%

Här har vi nu använt oss av två sätt att skicka en struct som parameter. Det tredje sättet är det normala, d.v.s. helt som en normal variabel utan & eller pekare. Vi kunde använt det sättet för funktionen skrivUt(), eftersom den inte behöver ändra värden i P, men för nyProdukt() måste vi använda någondera sättet som tillåter oss att ändra värden i P. Notera att om man använder & kan man direkt referera till medlemmar med en ., men använder man pekare är det lite mera knepigt. Det lättare sättet då man använder pekare är att använda sig av pilnotationen. En -> används för att avreferera en pekare som pekar på en struct (eller en klass) och accessera en medlem. Om man inte använder -> bör man först avreferera pekaren med *, och därefter avreferera medlemmen med en punkt (.). Använder man *-metoden bör man notera att . har högre precedens än *, och evalueras således först, vilket ju inte är vad vi vill. Vi vill först evaluera * och därefter .. Vi måste således använda en parentes för att tvinga fram en viss precedensordning. Med tanke på detta är -> att föredra. Notera att -> endast kan användas tillsammans med pekare.