Vandaag gaan we een van de belangrijke functies van de C- en C++-taal leren, namelijk de memmove()-functie. Maar laten we eerst even kijken naar de basisprincipes van de C- en C++-talen. We zullen ook bespreken welke functies er in beide C/C++-talen zijn.
De programmeertaal C is eenvoudig en redelijk effectief voor alle doeleinden. De implementatie van software zoals Windows OS, databases, tolken en andere tools is hiermee mogelijk. C is een geweldige taal voor beginners om de codering mee te leren. Daarom staat C-programmering bekend als de moedertaal, omdat het de basis vormt voor alle andere computertalen. De basis van de programmeertaal C++ is gebaseerd op de ideeën van objectgeoriënteerd programmeren (OOP). De gebruiker kan de principes van het programma gemakkelijk ontwikkelen en begrijpen, aangezien C++ een duidelijke structuur heeft. De programmeertaal C\C++ is uitzonderlijk veelzijdig in het uitvoeren van meerdere functies en het omschakelen van een variabele van het ene type naar het andere. De functie memmove() is een van de functies van C/C++.
De functie memmove() draagt tegelijkertijd 'aantal' bytes over van de inhoud van het geheugenblok dat wordt aangegeven door de bron naar de locatie die wordt aangegeven door de bestemming. De functie memmove() is alleen nuttig wanneer de bron- en doelobjecten elkaar overlappen en voorkomt dat het ongedefinieerde gedrag optreedt. Laten we voor meer informatie over de functie memmove() diep graven en kijken hoe we de syntaxis en voorbeelden in de functie memmove() kunnen implementeren.
Syntaxis:
Hier is dezelfde schrijfstijl en de implementatie van de functie memmove() voor zowel C- als C++-talen. Eerst schrijven we het sleutelwoord 'void', wat betekent dat als de functie geen waarde retourneert, we de naam schrijven van de functie die we willen implementeren, namelijk de functie memmove(). In de functiehaakjes schrijven we de bestemming zodat we de 'num' bytes kunnen plaatsen met het 'void' sleutelwoord. Vervolgens schrijven we de bronlocatie waar we de 'aantal' bytes vandaan halen.
Parameters:
hand: Adres naar de opslaglocatie waarnaar de gegevens worden gekopieerd.
src: Adres naar de opslaglocatie van waaruit de gegevens worden gekopieerd.
graaf: Hoeveelheid gegevens om van bron naar bestemming te kopiëren.
Winstwaarde:
In ruil daarvoor krijgen we het adres van het doelgeheugengebied. Dest wordt geretourneerd door de memmove() functie.
Voorbeeld 1: Implementatie van Memomove() Functie in C
Laten we beginnen met het implementeren van ons allereerste en eenvoudige voorbeeld van de C-taal. Om te beginnen met schrijven hebben we eerst een C-compiler nodig zodat we het programma kunnen schrijven en uitvoeren. Open daarvoor de C-compiler en begin met het implementeren van het programma.
#include#include
int hoofd ( )
{
char ch1 [ ] = { 'L' , 'i' , 'n' , 'in' , 'x' } ;
int lengte = grootte van ( 1l ) / De grootte van ( 1l [ 0 ] ) ;
printf ( 'Voordat de functie memmove() wordt toegepast: ' ) ;
voor ( int i = 0 ; i < lengte; ik++ )
{
printf ( '%c' , ch1 [ i ] ) ;
}
char * ch2 = & 1l [ twee ] ;
memmove ( 2l, 1l, grootte van ( char ) * twee ) ;
printf ( ' \n \n Na het toepassen van de functie memmove(): ' ) ;
voor ( int i = 0 ; i < 5 ; ik++ )
{
printf ( '%c ' , ch1 [ i ] ) ;
}
opbrengst 0 ;
}
We beginnen altijd met het inbouwen van de kernprogrammamodules na het starten van de compiler. Deze modules zijn de gebundelde C-taalmodules. We hoeven slechts één regel code te typen om deze modules op te nemen, in tegenstelling tot tientallen regels code om de module te bouwen. De '#'-indicator informeert de vertaler om eerst de module te laden voordat hij het sleutelwoord 'include' gebruikt om de module aan het programma toe te voegen. De module 'stdio.h' betekent dat de compiler de gegevens van de gebruiker accepteert en aan de gebruiker laat zien. De tweede module van het programma is “#include
Vervolgens starten we de functie main() zodat we de regel code kunnen schrijven die we in het programma willen implementeren. In regel 6 declareren we de karakterarraynaam 'ch1' van het type karakter. Vervolgens kennen we er een tekenwaarde aan toe. Daarna berekenen we de lengte van de 'ch1' en drukken we de invoerarray 'ch1' af met behulp van de 'for-lus'.
Daarna declareren we de aanwijzer naar de 'ch2' -array van een typeteken en wijzen we het adres van de 'ch1' -array toe aan de 'ch2' -array. Vervolgens printen we het met behulp van de printf() instructie. Laten we de uitvoer van de vorige illustratie bekijken:
Voorbeeld 2: Implementatie van de Memomove()-functie in C++
Hier is het basisvoorbeeld dat laat zien hoe de functie memmove() presteert in de C++-taal. Om te beginnen met schrijven hebben we eerst een C++ IDE nodig zodat we het programma kunnen schrijven en uitvoeren. Open daarvoor de C ++ -compiler en begin met de implementatie van het programma.
Na het openen van de compiler beginnen we altijd met het toevoegen van de headerbestanden die nodig zijn voor de programmeertaal C++ om de programma's te laten werken. Om het programma samen te stellen en de methode memmove() te gebruiken, voegen we eerst de twee fundamentele headerbestanden toe: 'iostream' en 'cstring'. C++ biedt verschillende manieren om met arrays en strings te werken. Deze functies zijn beschikbaar voor gebruik wanneer het headerbestand is opgenomen in een programma met het '#include
#include
namespace std; gebruiken;
int hoofd ( )
{
char src [ vijftig ] = '1234567890' ;
char bestemming [ vijftig ] = '0987654321' ;
cout << 'Voor het toepassen van memmove to Destination: ' << begin << einde;
memmove ( beste, src, 6 ) ;
cout << 'Na het toepassen van memmove naar bestemming: ' << handen
opbrengst 0 ;
}
We beginnen met het schrijven van de functie main() om de uitvoering van een daadwerkelijke coderegel te starten. In regel 7 staat een array van twee tekens met een lengte van 50 die wordt gedeclareerd als 'src[50]' en 'dest[50]'. We gebruiken de instructie 'cout' om het bericht 'Voordat memmove() to Destination: wordt toegepast' af te drukken. Vervolgens geven we de parameter 'dest' door om de waarde van de array 'dest' af te drukken. Vervolgens wordt de functie memmove() toegepast op de tekentypevariabele die is gedeclareerd als 'src[50]' en 'dest[50]' om het bepaalde aantal bytes van de oorsprong(src) naar het doel(dest) te overlappen met de aantal 'tellen'. Dit identificeert het aantal bytes dat is gekopieerd van 'src' naar 'dest'. Zoals u in de volgende afbeelding kunt zien, hebben we het telnummer '6' verklaard.
Daarna gebruiken we de instructie 'cout' opnieuw om het bericht 'Na toepassing van memmove() op bestemming:' weer te geven en geven we de variabele 'dest' -array van het type 'character' door. Om te voorkomen dat het programma wordt uitgevoerd, moeten we een return-instructie gebruiken aan het einde van het programma. Vervolgens keren we 0 terug naar de hoofdfunctie, wat aangeeft dat het programma met succes is uitgevoerd en zijn doel heeft bereikt.
U kunt in de volgende uitvoer van de methode memmove() zien dat als er sprake is van overlapping, bijvoorbeeld wanneer de eerste aanwijzer naar de letter 6 gaat, de aanwijzer blijft afdrukken en de volgende tekens elkaar overlappen. Dit C++-codefragment is uitgevoerd en de resultaten worden weergegeven in de volgende afbeelding:
Conclusie
In dit artikel leerden we over de functie memmove() in de programmeertalen C en C++. We hebben gesproken over hoe de functie memmove() werkt aan de hand van het voorbeeld van C en C++ met een gedetailleerde uitleg van elke regel code. We hopen dat u dit artikel nuttig vindt bij het ontwikkelen van uw kennis over de functie memmove() in C en C++.