Structuren en klassen in C++

C++ blijft een minderheidstaal voor embedded ontwikkeling, maar wordt vaak gebruikt door ontwikkelaars wanneer projecten te groot worden om C efficiënt te gebruiken. Deze ontwikkelaars stappen doorgaans over van C naar C++ en de subtiele verschillen tussen de talen vertegenwoordigen een aanzienlijk deel van hun leercurve. C++ heeft structuren, net als C, doordat ze niet hetzelfde zijn. C++ heeft klassen, die opmerkelijk veel op structuren lijken. Dit artikel ontsluit de details van deze taalelementen.

Structuren in C

Een structuur in C is een aangepast, samengesteld gegevensitem (object), dat kan worden opgebouwd uit de bestaande ingebouwde gegevenstypen (int , char , enz.), bitvelden (gehele getallen van gespecificeerde bitgrootte) en andere structuren. Het idee is om een ​​aantal gegevens die bij elkaar horen te aggregeren. Een structuur voor driedimensionale coördinaten kan er bijvoorbeeld als volgt uitzien:

struct coördinaten{   float x; zweven y; float z;};

Deze code vertelt de compiler wat een struct coördineert lijkt op. U kunt dan variabelen van dit type als volgt declareren:

struct coördinaten locatie;

De variabele locatie is van het type struct coördinaten en de interne velden kunnen worden geadresseerd met behulp van de "punt"-operator:

locatie.x =1.0;locatie.y =2.0;locatie.z =9,99;

Natuurlijk kan een soortgelijk effect worden bereikt met drie afzonderlijke float variabelen met namen als location_x enz. Het is echter veel gemakkelijker om locatie te hanteren als een enkele variabele die kan worden doorgegeven aan functies enz.

De mogelijkheid om bitvelden op te nemen geeft structuren een mogelijkheid die elders in C niet beschikbaar is. Hier is een voorbeeld:

struct bitreg{   niet aangemeld:3; niet afgetekend:3; niet-ondertekende polariteit:2;};

Elk van de velden in een variabele van het type struct bitreg heeft een specifieke bitgrootte. De complier zorgt ervoor dat de gegevens op een verstandige manier worden opgeslagen, dus we zouden verwachten dat zo'n variabele in één byte past. Bovendien wordt alle "bit bashing"-code om toegang te krijgen tot de velden binnen de byte automatisch gegenereerd. De programmeur kan ze dus eenvoudig als volgt openen:

struct bitreg controle; control.up =1;control.down =2;control.polariteit =3;

Voor het grootste deel is het gebruik van structuren in C vrij eenvoudig en maakt het de code gemakkelijker te begrijpen zonder invloed op de uitvoeringsefficiëntie. Er zijn echter twee punten waar embedded ontwikkelaars rekening mee moeten houden:

• Moderne, high-end (meestal 32-bits) processors hebben instructiesets die het gebruik van structuren gemakkelijk accommoderen. Inderdaad, ze zijn ontworpen om precies dit te doen. De meeste lagere CPU's bieden echter niet zo'n efficiëntie, dus het gebruik van structuren vereist voorzichtigheid.
• Bitvelden zijn een leuke functie en kunnen resulteren in efficiënte en leesbare code. Ingebedde ontwikkelaars zien mogelijk meteen een kans:gebruik bitvelden om toegang te krijgen tot apparaatcontroleregisters. Veel randapparatuur hebben registers die 1 woord of 1 byte breed zijn en verschillende bitvelden bevatten. Dit ziet eruit als een geweldige match en soms kan het werken. Maar er zijn twee problemen:
  • De exacte lay-out van de bitvelden wordt bepaald door de compiler. Als alles correct op een apparaat wordt weergegeven, werkt de code mogelijk goed. Een wijziging van de compiler, of zelfs maar een update van de compiler, kan de code echter breken.
  • De code die door de compiler wordt gegenereerd om toegang te krijgen tot de bitvelden, zal hoogstwaarschijnlijk een aantal EN/OF-bewerkingen en meerdere toegangen tot het register gebruiken, wat problematisch kan zijn. Bovendien zijn sommige apparaatregisters alleen-schrijven en dat zou nooit worden ondergebracht in door de compiler gegenereerde code.

Hoewel een C-structuur enigszins lijkt op een nieuw gegevenstype, is het dat niet echt. Een gegevenstype heeft normaal gesproken een reeks bewerkingen die erop kunnen worden uitgevoerd; dit is niet het geval voor een C-structuur. Om iets met een C-structuur te doen, behalve een verwijzing ernaar, moet u toegang krijgen tot de interne velden. Deze kwestie wordt behandeld in C++.

Klassen in C++

De taal C++ heeft een aantal objectgeoriënteerde mogelijkheden. Een daarvan is het concept van een klasse , wat de beschrijving mogelijk maakt van iets dat veel meer lijkt op een nieuw gegevenstype. Een variabele (normaal een object genoemd) ) kan worden geïnstantieerd uit de klas; d.w.z. het is een object van dit nieuwe type.

Een C++-klasse heeft bijna exact dezelfde syntaxis als een C-structuur en enkele zeer vergelijkbare mogelijkheden. Er zijn echter enkele belangrijke verschillen:

• Een klasse kan ook functies bevatten (genaamd methoden ).
• De lidvariabelen en methoden zijn verborgen voor de buitenwereld, tenzij hun declaratie volgt op een public:
• Er kunnen een paar speciale methoden zijn - de constructor en de destructor - die automatisch worden uitgevoerd wanneer een instantie van de klasse (een object) respectievelijk wordt gemaakt en vernietigd.
• Operators die aan het nieuwe gegevenstype werken, kunnen worden gedefinieerd met behulp van speciale methoden (lidfuncties).
• De ene klasse kan worden gebruikt als basis voor de definitie van een andere (dit wordt overerving genoemd) ).
• Het declareren van een variabele van het nieuwe type (een instantie van de klasse; een object) vereist alleen de naam van de klasse - het sleutelwoord class is niet vereist.

De meeste van deze functies worden geïllustreerd in dit voorbeeld:

class myclass{   char  a; int   b;public:   void fun(); mijn klas(); ~mijnklasse();}; mijnklasse mijnobj; myobj.fun();

De lidvariabelen a en b zijn alleen toegankelijk voor de drie ledenfuncties fun() , mijnklasse() en ~myclass() . De laatste twee functies zijn de constructor en de destructor. Alleen leuk() wordt waarschijnlijk aangeroepen door de gebruikerscode. De eigenlijke code voor alle drie de functies zou elders worden gedefinieerd en wordt aan de klasse gekoppeld met behulp van de :: operator, dus:

void myclass::fun(){  ...

Structuren in C++

Naast klassen heeft C++ structuren die achterwaarts compatibel zijn met C. Een C++-structuur heeft echter ook dezelfde extra mogelijkheden als klassen. Het is slechts één verschil tussen een structuur en een klasse in C++. De standaardtoegankelijkheid van lidvariabele en functies in een klasse is privé, zoals we hebben gezien; de standaard in een struct is openbaar. De functionaliteit van de eerdere klasse kan dus ook als volgt worden uitgedrukt:

struct mystruct{   void fun(); mijn klas(); ~myclass();private:   char  a; int   b;};

Klassen en structuren gebruiken in C++

Nadat u deze informatie hebt verkregen, wordt u dringend verzocht er niet te veel gebruik van te maken. Er zijn veel redenen om alleen structuren te gebruiken voor het soort functionaliteit dat ze bieden in C en klassen wanneer je de extra mogelijkheden nodig hebt. Het is in de eerste plaats een kwestie van de leesbaarheid van de code. Een andere ontwikkelaar is misschien niet zo duidelijk over de details en code die op een "niet-standaard" manier is geschreven, zal verwarrend zijn.

Een belangrijke prioriteit bij het schrijven van code is ervoor te zorgen dat deze leesbaar is (=onderhoudbaar). Iemand - jij zou het kunnen zijn - moet over een jaar misschien naar deze code kijken en begrijpen wat het doet. Wat advies:neem aan dat de persoon die uw code zal onderhouden een gewapende psychopaat is, die weinig geduld heeft en uw thuisadres kent.