Ik lees een boek genaamd “Leer jezelf CE in 21 dagen” (ik heb Java en C # al geleerd, dus ik ben in een veel snellere tempo in beweging). Ik lees het hoofdstuk over de aanwijzingen en de ->(pijl) operator kwam zonder uitleg. Ik denk dat het wordt gebruikt om leden en functies te bellen (zoals het equivalent van de operator .(DOT), maar voor aanwijzingen in plaats van leden). Maar ik ben niet helemaal zeker.
Kan ik alsjeblieft een verklaring en een code-monster krijgen?
1, Autoriteit 100%
foo->baris gelijk aan (*foo).bar, dwz het krijgt het lid genaamd barvan de Structure foopunten naar.
2, Autoriteit 27%
Ja, dat is het.
Het is gewoon de puntversie wanneer u toegang wilt tot elementen van een struct / klasse die een aanwijzer is in plaats van een referentie.
struct foo
{
int x;
float y;
};
struct foo var;
struct foo* pvar;
pvar = malloc(sizeof(struct foo));
var.x = 5;
(&var)->y = 14.3;
pvar->y = 22.4;
(*pvar).x = 6;
Dat is het!
3, Autoriteit 7%
a->bis slechts kort voor (*a).bop elke manier (hetzelfde voor functies: a->b()is kort voor (*a).b()).
4, Autoriteit 6%
Ik zou gewoon toevoegen aan de antwoorden “waarom?”.
.is standaard-toegangsoperator met een hogere precedentie dan *aanwijzeroperator.
Wanneer u probeert toegang te krijgen tot de internals van een struct en schreef u het als *foo.bardan zou de compiler denken om een ’bar’ element van ‘foo’ te willen hebben (wat een adres is geheugen) en duidelijk dat louter adres geen leden heeft.
U moet dus de compiler vragen om de eerste derference whith (*foo)te vragen en vervolgens toegang te krijgen tot het Lid-element: (*foo).bar, wat een beetje is onhandig om te schrijven, zodat de goede mensen een steno-versie hebben bedacht: foo->bardie een beetje lid is van Pointer Operator.
5, Autoriteit 4%
foo->baris alleen steno voor (*foo).bar. Dat is alles wat er is.
6
Ik moest een kleine wijziging van het programma van Jack aanbrengen om het te laten rennen. Nadat u de Struct Pointer PVAR hebt aangetrokken, wijst u het naar het adres van VAR. Ik vond deze oplossing op pagina 242 van de programmering van Stephen Kochan in c.
#include <stdio.h>
int main()
{
struct foo
{
int x;
float y;
};
struct foo var;
struct foo* pvar;
pvar = &var;
var.x = 5;
(&var)->y = 14.3;
printf("%i - %.02f\n", var.x, (&var)->y);
pvar->x = 6;
pvar->y = 22.4;
printf("%i - %.02f\n", pvar->x, pvar->y);
return 0;
}
Voer dit in VIM met de volgende opdracht:
:!gcc -o var var.c && ./var
wordt uitgevoerd:
5 - 14.30
6 - 22.40
7
#include<stdio.h>
int main()
{
struct foo
{
int x;
float y;
} var1;
struct foo var;
struct foo* pvar;
pvar = &var1;
/* if pvar = &var; it directly
takes values stored in var, and if give
new > values like pvar->x = 6; pvar->y = 22.4;
it modifies the values of var
object..so better to give new reference. */
var.x = 5;
(&var)->y = 14.3;
printf("%i - %.02f\n", var.x, (&var)->y);
pvar->x = 6;
pvar->y = 22.4;
printf("%i - %.02f\n", pvar->x, pvar->y);
return 0;
}
8
De ->-operator maakt de code leesbaarder dan de bediener *in sommige situaties.
Zoals: (geciteerd uit de EDK II project )
typedef
EFI_STATUS
(EFIAPI *EFI_BLOCK_READ)(
IN EFI_BLOCK_IO_PROTOCOL *This,
IN UINT32 MediaId,
IN EFI_LBA Lba,
IN UINTN BufferSize,
OUT VOID *Buffer
);
struct _EFI_BLOCK_IO_PROTOCOL {
///
/// The revision to which the block IO interface adheres. All future
/// revisions must be backwards compatible. If a future version is not
/// back wards compatible, it is not the same GUID.
///
UINT64 Revision;
///
/// Pointer to the EFI_BLOCK_IO_MEDIA data for this device.
///
EFI_BLOCK_IO_MEDIA *Media;
EFI_BLOCK_RESET Reset;
EFI_BLOCK_READ ReadBlocks;
EFI_BLOCK_WRITE WriteBlocks;
EFI_BLOCK_FLUSH FlushBlocks;
};
De _EFI_BLOCK_IO_PROTOCOLSTOCK Bevat 4 Function Pointer-leden.
Stel dat je een variabele struct _EFI_BLOCK_IO_PROTOCOL * pStructhebt, en je wilt de goede oude operator *gebruiken om zijn lidfunctieaanwijzer aan te roepen. Je krijgt een code als deze:
(*pStruct).ReadBlocks(...arguments...)
Maar met de operator ->kun je als volgt schrijven:
pStruct->ReadBlocks(...arguments...).
Wat ziet er beter uit?
Antwoord 9
#include<stdio.h>
struct examp{
int number;
};
struct examp a,*b=&a;`enter code here`
main()
{
a.number=5;
/* a.number,b->number,(*b).number produces same output. b->number is mostly used in linked list*/
printf("%d \n %d \n %d",a.number,b->number,(*b).number);
}
uitvoer is 5
5 5
Antwoord 10
Dot is een dereferentie-operator en wordt gebruikt om de structuurvariabele voor een bepaald structuurrecord te verbinden.
Bijv.:
struct student
{
int s.no;
Char name [];
int age;
} s1,s2;
main()
{
s1.name;
s2.name;
}
Op die manier kunnen we een puntoperator gebruiken om toegang te krijgen tot de structuurvariabele