C++ Constexpr-tekenreeksvoorbeelden

Wat is het gebruik van de C++ Constexpr-reeks?

Het gebruik van constexpr kan leiden tot compactere en geoptimaliseerde uitvoerbare bestanden. Omdat de waarden vooraf door de compiler worden bepaald, kunnen de resulterende binaire bestanden kleiner van formaat zijn, waardoor een zuiniger gebruik van systeembronnen wordt gerealiseerd, wat op zijn beurt de prestaties van de software op verschillende platforms kan verbeteren. Een bijzonder belangrijk voordeel van deze functie is de vermindering van de runtime-berekeningen. Omdat waarden waar mogelijk tijdens het compilatieproces worden berekend, wordt de runtime-evaluatie minder noodzakelijk. Deze efficiëntieverbetering versnelt niet alleen de uitvoering, maar stroomlijnt ook de algehele programma-operaties.

Voorbeeld 1: Constexpr gebruiken in C++ voor factoriële berekening

In dit voorbeeld gebruiken we constexpr waarmee de berekeningen tijdens het compileren kunnen worden uitgevoerd in plaats van tijdens runtime. In de context van het berekenen van faculteiten kan een algemene wiskundige bewerking, namelijk constexpr, worden gebruikt om factoriële waarden te berekenen tijdens het compileren. Laten we de volgende code onderzoeken en beoordelen en vervolgens kijken naar de uitleg van de code:

Het gegeven codevoorbeeld demonstreert het gebruik van constexpr voor het recursief berekenen van de faculteit van een getal. In dit voorbeeld kan de compiler de factoriële expressie tijdens het compileren evalueren, omdat de factoriële functie wordt gedeclareerd en gedefinieerd met de constexpr-specificatie. Met behulp van constexpr in een C++-programma evalueert de compiler de factoriële expressie van 5 tijdens het compileren, waardoor er geen runtime-berekeningen meer nodig zijn.

Laten we nu de gedetailleerde uitsplitsing van de code bekijken met specifieke details en uitleg.

Ten eerste gebruiken we de #include om het “iostream” headerbestand op te nemen dat essentiële invoer- en uitvoerfunctionaliteiten biedt, zoals “std::cout” voor afdrukken naar de console.

Daarna gaan we naar de functie factorial() (recursief), die 'constexpr int faculteit(int n)' is. Deze factorial()-functie definieert een recursieve functie die de faculteit van een geheel getal “n” berekent. Constexpr impliceert dat prestatie-optimalisaties kunnen voortvloeien uit het evalueren van de functie tijdens compilatie.

Het rendement n <= 1 ? 1: (n * faculteit(n – 1)) regel gebruikt een voorwaardelijke uitdrukking voor recursie die stelt dat als “n” kleiner is dan of gelijk is aan 1, deze 1 retourneert (basisscenario). Als dat niet het geval is, voert het de factoriële berekening uit (n! = n * (n-1)!), wat de algemene formule is voor het berekenen van de faculteit, door zichzelf herhaaldelijk aan te roepen met “n – 1” en het resultaat vervolgens te vermenigvuldigen met “n ”. Deze lijnen fungeren als poortwachters voor factoriële berekeningen. Het controleert of het getal zich op het basisniveau bevindt en retourneert 1 als dat het geval is. Als dat niet het geval is, brengt dit een kettingreactie van functieaanroepen op gang, die elk op kleinere getallen werken totdat het basisscenario is bereikt. Vervolgens worden de resultaten in omgekeerde volgorde met elkaar vermenigvuldigd. Het volgende is de uitvoer van de code ter referentie:

Voorbeeld 2: Kleine letters tellen en de C++ Constexpr-reeks demonstreren

Hier zullen we leren hoe we het aantal kleine letters kunnen tellen met behulp van een countexpr-reeks. In dit voorbeeld is het de bedoeling om het aantal kleine letters in een bepaalde string te tellen met behulp van de constexpr-functie om de runtime-berekening te verminderen. De functie countLowercase(), gedeclareerd als constexpr, neemt een “string_view”-tekenreeks als parameter en doorloopt elk teken van de gegeven tekenreeks als invoer. Voor elke kleine letter die we tegenkomen, wordt de telling verhoogd. Het resultaat wordt vervolgens verkregen tijdens het compileren terwijl de functie werkt op basis van constante expressies, wat de efficiëntie- en prestatievoordelen van de evaluatie tijdens het compileren laat zien. Controleer eerst de volgende code. Ga dan verder met de gedetailleerde uitleg:

Hier is een gedetailleerd overzicht van de code met een uitleg van elke regel:

De #include is inbegrepen om de standaard input/output stream-bibliotheek te gebruiken om de berichten af ​​te drukken. De #include bevat de klasse “string_view” voor efficiënte tekenreeksmanipulatie.

In de functie countLowercase() telt de functie “constexpr size_t countlower(string_view s)” de kleine letters in een bepaalde tekenreeksweergave. De int main() is het startpunt van het programma dat een bericht afdrukt dat het aantal kleine letters in “LoWeR Case LeTtErS” aangeeft en de functie countLowercase() aanroept met “LoWeR Case LeTtErS” als invoer en het resultaat afdrukt. Raadpleeg de volgende uitvoer van het programma:

Voorbeeld 3: Arraydemonstratie door gebruik te maken van de C++ Constexpr

Een array-demonstratie laat zien hoe de arrays, die gestructureerde verzamelingen van elementen van hetzelfde gegevenstype zijn, worden gemaakt, benaderd en gemanipuleerd binnen een programmeertaal. Hieronder zullen we dit uitleggen aan de hand van een coderingsvoorbeeld waarin het programma een eenvoudig voorbeeld geeft van array-initialisatie en -manipulatie tijdens het compileren.

Een array-demonstratie illustreert het concept van arrays (een gestructureerde verzameling elementen die hetzelfde gegevenstype delen) en hoe deze kunnen worden gemaakt, geopend en gemanipuleerd met behulp van een programmeertaal. In het volgende codevoorbeeld laten we zien hoe u een array tijdens het compileren kunt initialiseren, de grootte ervan kunt berekenen en de elementen van de gegeven array kunt afdrukken. Zie de volgende gegeven code en ga verder met de uitleg:

Dit programma initialiseert een constexpr-array, berekent de lengte ervan tijdens het compileren en drukt vervolgens de lengte en elementen van de array af naar de console. Constexpr zorgt ervoor dat de array en zijn eigenschappen tijdens het compileren worden bepaald. Laten we de code breken en de specifieke details één voor één uitleggen:

Om de standaard input-output stream-bibliotheek op te nemen, waardoor het gebruik van functies zoals “cout” voor uitvoer mogelijk wordt gemaakt, wordt #include aangeroepen. Het programma begint de uitvoering vanuit de int main() functie. Binnen de functie main() is de array “arrayint[]” gedefinieerd, met een grootte van 9, met een constexpr int arrayint[9]-instructie. De array wordt geïnitialiseerd met vijf cijfers, en de overige elementen bleven impliciet 0. De int lengte_a = sizeof arrayint / sizeof(int); berekent de grootte van de 'arrayint' in bytes.

Een “for”-lus doorloopt de elementen van de “arrayint[]”array en de waarden worden vervolgens naar de console afgedrukt. Laten we de volgende uitvoer van de gegeven code bekijken:

Conclusie

De introductie en evolutie van het trefwoord constexpr in C++ heeft een revolutie teweeggebracht in de manier waarop met constante expressies en waarden wordt omgegaan. In dit artikel worden drie praktische voorbeelden onderzocht, waarbij de kracht van constexpr wordt getoond bij het berekenen van faculteiten, het tellen van de kleine letters en het initialiseren van de arrays tijdens het compileren. De belangrijkste punten zijn onder meer verbeterde prestaties, kortere runtimeberekeningen en verbeterde geheugenefficiëntie. Constexpr is een waardevol bezit voor het creëren van betrouwbare, constante entiteiten binnen een codebase, waardoor onveranderlijkheid wordt gegarandeerd en wordt bijgedragen aan meer gestroomlijnde en efficiënte programma's.