Toegang tot modificatoren in C++
Toegangsmodificatoren worden gebruikt om de toegankelijkheid en de zichtbaarheid van de gegevens van een klasse te beheren. Ze stellen enkele beperkingen aan de gegevensleden, zodat externe functies er geen toegang toe hebben. De toegangsmodificatoren zijn van drie typen in C++:
Modifier voor openbare toegang in C++
Alle leden van de klasse die onder het trefwoord public zijn gedeclareerd, zijn beschikbaar voor alle functies buiten de klasse binnen het programma. De directe ledentoegangsoperator (.), ook wel de puntoperator genoemd, kan worden gebruikt met het object van die specifieke klasse om toegang te krijgen tot deze gegevensleden.
Voorbeeld
De public access modifier wordt gebruikt om een klasse te declareren, en de gegevensleden ervan zijn toegankelijk voor de andere functies binnen het programma.
#include
#include
#include
namespace std; gebruiken ;
klasse Driehoek
{
openbaar :
vlot X , En , Met ;
leegte invoer ( )
{
uit << 'Voer de zijde x van een driehoek in:-' ;
aan het eten >> X ;
uit << 'Voer de zijde y van een driehoek in:-' ;
aan het eten >> En ;
uit << 'Voer de zijde z van een driehoek in:-' ;
aan het eten >> Met ;
}
leegte Gebied ( )
{
vlot S = ( X + En + Met ) / 2 ;
vlot gebied = sqrt ( S * ( S - X ) * ( S - En ) * ( S - Met ) ) ;
uit << ' \N Gebied van driehoek =' << gebied ;
}
} ;
int voornaamst ( )
{
Driehoek t1 ;
t1. invoer ( ) ;
t1. Gebied ( ) ;
opbrengst 0 ;
}
De Triangle wordt gedefinieerd als de klasse en de parameters ervan staan onder het openbare trefwoord. Vervolgens wordt het gebied van de driehoek buiten deze klasse berekend door toegang te krijgen tot de gegevensleden van de openbare modifier.
De drie zijden van de driehoek worden door de gebruiker ingevoerd en de oppervlakte van de driehoek wordt berekend door toegang te krijgen tot de waarden buiten de klasse, met behulp van de standaardformule, namelijk 13,4164.
Modifier voor privétoegang in C++
Alle leden van de klasse die onder het trefwoord private zijn gedeclareerd, zijn voor geen enkele functie buiten de klasse in het programma beschikbaar. Deze privéleden kunnen alleen worden gelezen door de directe leden binnen dezelfde klasse. Vriendenfuncties en klassen hebben echter ook toegang tot de gegevens.
Voorbeeld
De twee klassen publiek en privé worden gedeclareerd en de geretourneerde waarde van het programma moet het gebied van de driehoek zijn.
#include#include
#include
namespace std; gebruiken ;
klasse Driehoek
{
privaat :
vlot X , En , Met ;
openbaar :
leegte invoer ( )
{
uit << 'Voer de zijde x van een driehoek in:-' ;
aan het eten >> X ;
uit << 'Voer de zijde y van een driehoek in:-' ;
aan het eten >> En ;
uit << 'Voer de zijde z van een driehoek in:-' ;
aan het eten >> Met ;
}
leegte Gebied ( )
{
vlot S = ( X + En + Met ) / 2 ;
vlot gebied = sqrt ( S * ( S - X ) * ( S - En ) * ( S - Met ) ) ;
uit << ' \N Gebied van driehoek =' << gebied ;
}
} ;
int voornaamst ( )
{
Driehoek t1 ;
t1. invoer ( ) ;
t1. Gebied ( ) ;
opbrengst 0 ;
}
In main() heeft het object t1 geen directe toegang tot de privéklassevariabele float x, y en z, dus kan het alleen indirect worden gemanipuleerd via de publieke functie input(), aangezien deze functie de waarden van x, y en z verkrijgt.
Het gebied van de driehoek wordt verkregen door toegang te krijgen tot de privéklasse door deze te manipuleren met behulp van de openbare klasse. Als de waarden van x, y en z niet in de openbare klasse worden gedeclareerd, zijn ze niet toegankelijk in main() voor berekeningen.
Beschermde toegangsmodificator in C++
De leden en functies onder het beschermde trefwoord zijn beschermd, ze zijn alleen toegankelijk binnen de klasse en de afgeleide klasse. De rest van de klassen heeft geen toegang tot hun gegevens. Ze zijn zeer beschermd.
Voorbeeld
De beschermde gegevens onder het beschermde trefwoord kunnen alleen worden gelezen binnen de klasse en door de klasse die de afgeleide klasse is. Dit voorbeeld is de praktische demonstratie van de beschermde toegangsmodificator.
#include#include
#include
namespace std; gebruiken ;
//ouderklasse
klasse Driehoek
{
beschermd :
vlot X , En , Met ;
} ;
//kinderklas
klasse DriehoekKind : publieke driehoek {
openbaar :
leegte invoer ( )
{
uit << 'Voer de zijde x van een driehoek in:-' ;
aan het eten >> X ;
uit << 'Voer de zijde y van een driehoek in:-' ;
aan het eten >> En ;
uit << 'Voer de zijde z van een driehoek in:-' ;
aan het eten >> Met ;
}
leegte Gebied ( )
{
vlot S = ( X + En + Met ) / 2 ;
vlot gebied = sqrt ( S * ( S - X ) * ( S - En ) * ( S - Met ) ) ;
uit << ' \N Gebied van driehoek =' << gebied ;
}
} ;
int voornaamst ( )
{
DriehoekKind Kind ;
Kind. invoer ( ) ;
Kind. Gebied ( ) ;
opbrengst 0 ;
}
TriangleChild is een erfelijke klasse die is afgeleid van de klasse Triangle. De variabelen x, y en z worden gedeclareerd in Triangle met het beschermde trefwoord. Dit betekent dat deze variabelen beschermd zijn, maar toegankelijk zijn voor TriangleChild, aangezien Triangle de bovenliggende klasse is. De waarden van variabelen zijn toegewezen in TriangleChild, ook al zijn ze gedeclareerd in de klasse Triangle.
De variabelen zijn toegankelijk via de onderliggende klasse en vervolgens wordt de oppervlakte van een driehoek berekend.
Conclusie
Het verbergen van gegevens voorkomt ongewenste toegang tot de gegevens van een klas van buitenaf. Toegangsmodificatoren worden gebruikt om de toegankelijkheid en de zichtbaarheid van de gegevens in een programma te beheren. Er worden privé-, beschermde en openbare toegangsmodificatoren gebruikt om de gegevens te verbergen. Gegevens onder het trefwoord public kunnen ook door de functies van buiten de klasse worden gelezen. De gegevens die als privé zijn verklaard, kunnen alleen binnen de klasse worden gelezen, terwijl beschermde gegevens ook toegankelijk zijn voor de bovenliggende en onderliggende klasse.