Dans c, un indicateur est une variable qui se dirige à ou met en référence un endroit de mémoire dans lequel des données sont stockées. Dans l'ordinateur, chaque cellule de mémoire a une adresse qui peut être employée pour accéder à cet endroit ainsi à points d'une variable d'indicateur à un endroit de mémoire que nous pouvons accéder et changeons le contenu de cet endroit de mémoire par l'intermédiaire de l'indicateur.

Déclaration d'indicateur :

Un indicateur est une variable qui contient l'endroit de mémoire d'une autre variable dans des données de shich est stockée. En utilisant l'indicateur, vous commencez par indiquer le type de données stockées dans l'endroit. L'astérisque aide à indiquer au compilateur que vous créez une variable d'indicateur. Enfin vous devez donner le nom de la variable. La syntaxe est comme montrée ci-dessous.

type * variable name

L'exemple suivant illustrent le declataion de la variable d'indicateur

int *ptr;
float *string;

Opérateur d'adresse :

Une fois que nous déclarons une variable d'indicateur puis nous devons la diriger à quelque chose que nous pouvons faire ceci en assignant à l'indicateur l'adresse de la variable vous voulez se diriger comme dans l'exemple suivant :

ptr=#

Le code ci-dessus indique que l'adresse où numérique est des magasins dans le PTR variable. Le PTR variable a la valeur 21260, si numérique est stocké dans l'adresse de la mémoire 21260 alors

Le programme suivant illustrent la déclaration d'indicateur

/* A program to illustrate pointer declaration*/

main()
{
int *ptr;
int sum;
sum=45;
ptr=&sum
printf ("\n Sum is %d\n", sum);
printf ("\n The sum pointer is %d", ptr);
}

Expressions d'indicateur et arithmétique d'indicateur :

Dans les expressions, comme d'autres variables d'indicateur de variables peut être employé. Par exemple si p1 et p2 sont correctement initialisés et les indicateurs avoués, alors les rapports suivants sont valides.

y=*p1**p2;
sum=sum+*p1;
z= 5* - *p2/p1;
*p2= *p2 + 10;

C nous permet de soustraire des nombres entiers à ou d'ajouter des nombres entiers des indicateurs aussi bien que pour soustraire un indicateur de l'autre. Nous pouvons également employer les opérateurs courts de main avec les indicateurs p1+= ; sum+=*p2 ; etc., en employant des opérateurs de relation, nous pouvons également comparer des indicateurs comme les expressions telles que p1 >p2, p1==p2 et p1 ! on permet =p2.

Le programme suivant illustrent l'expression d'indicateur et l'arithmétique d'indicateur

/*Program to illustrate the pointer expression and pointer arithmetic*/
#include< stdio.h >
main()
{ int ptr1,ptr2;
int a,b,x,y,z;
a=30;b=6;
ptr1=&a;
ptr2=&b;
x=*ptr1+ *ptr2 6;
y=6*- *ptr1/ *ptr2 +30;
printf("\nAddress of a +%u",ptr1);
printf("\nAddress of b %u",ptr2);
printf("\na=%d, b=%d",a,b);
printf("\nx=%d,y=%d",x,y);
ptr1=ptr1 + 70;
ptr2= ptr2;
printf("\na=%d, b=%d,"a,b);
}

Indicateurs et fonction :

Dans une déclaration de fonction, l'indicateur sont tout d'abord employés. Parfois, seulement avec un indicateur une fonction complexe peut être facilement représentée et succès. Dans une définition de fonction, l'utilisation des indicateurs peut être classifiée dans deux groupes.

Appel par la référence
Appel par valeur.

Appel par valeur :

Nous avons vu qu'il y aura un lien établi entre les paramètres formels et effectifs quand une fonction est appelée. Dès que la mémoire temporaire sera créée où la valeur des paramètres effectifs est stockée. Les paramètres formels prend sa valeur de zone de stockage le mécanisme du transfert de données entre formel et les paramètres effectifs permet le mécanisme de paramètres effectifs du transfert de données est référé comme appel par valeur. Le paramètre formel correspondant représente toujours une variable locale dans la fonction appelée. La valeur courante du paramètre effectif correspondant devient la valeur initiale du paramètre formel. Dans le corps du paramètre effectif, la valeur du paramètre formel peut être changée. Dans le corps du sous-programme, la valeur du paramètre formel peut être changée par des rapports de tâche ou d'entrée. Ceci ne changera pas la valeur des paramètres effectifs.

/* Include< stdio.h >

void main()
{
int x,y;
x=20;
y=30;
printf("\n Value of a and b before function call =%d %d",a,b);
fncn(x,y);
printf("\n Value of a and b after function call =%d %d",a,b);
}

fncn(p,q)
int p,q;
{
p=p+p;
q=q+q;
}

Appel par la référence :

L'adresse devrait être des indicateurs, quand nous passons à adresse à une fonction la réception de paramètres. En employant des indicateurs, le processus d'appeler une fonction pour passer l'adresse de la variable est connu comme appel par la référence. La fonction qui s'appelle par la référence peut changer la valeur de la variable utilisée dans l'appel.

/* example of call by reference*?

/* Include< stdio.h >
void main()
{
int x,y;
x=20;
y=30;
printf("\n Value of a and b before function call =%d %d",a,b);
fncn(&x,&y); printf("\n Value of a and b after function call =%d %d",a,b);
}
fncn(p,q)
int p,q;
{
*p=*p+*p;
*q=*q+*q;
}

Indicateur aux rangées :

une rangée est réellement beaucoup semblable comme l'indicateur. Nous pouvons déclarer car le *a interne est une adresse, parce qu'a [0] le premier élément de rangées comme a [0] et le *a est également une adresse la forme de déclaration est également équivalent. La différence est indicateur peut apparaître du côté gauche de l'opérateur de tâche et c'est a est une variable qui est lvalue. Le nom de rangée ne peut pas apparaître en tant que côté gauche d'opérateur de tâche et est constant.

/* A program to display the contents of array using pointer*/
main()
{
int a[100];
int i,j,n;
printf("\nEnter the elements of the array\n");
scanf(%d,&n);
printf("Enter the array elements");
for(I=0;I< n;I++)
scanf(%d,&a[I]);
printf("Array element are");
for(ptr=a,ptr< (a+n);ptr++)
printf("Value of a[%d]=%d stored at address %u",j+=,*ptr,ptr);
}

Indicateurs et structures

Nous savons que le nom des stands d'une rangée pour l'adresse de son élément de zeroth que le même concept applique pour des noms des choix de structures. Supposer que l'article est une variable de rangée du type de struct. Considérer la déclaration suivante :

struct products
{
char name[30];
int manufac;
float net;
item[2],*ptr;

ce PTR de rapport en tant qu'objets des données d'indicateur de type produits de struct et déclare l'article comme choix de deux éléments, chaque type produits de struct.

Indicateurs sur l'indicateur

Un indicateur contient la valeur d'ordures jusqu'à ce qu'il soit initialisé. Puisque les compilateurs ne peuvent pas détecter les erreurs ne peuvent être connues jusqu'à ce que nous exécutions le programme nous rappelions que même si nous pouvons localiser un résultat faux, uninitialized ou a incorrectement initialisé des indicateurs qu'il peut ne pas fournir aucune évidence pour nous aux problèmes suspects dans les indicateurs. Par exemple les expressions comme

*ptr++, *p[],(ptr).member

Keywords: Pointers in C, double pointers in c, pointers in c language, pointer in c, pointers in c++, function pointers in c, function pointer in c, using pointers in c, data types in c, array of pointers in c, pointers in c#, pointer to pointer in c, pointer to a pointer in c, pointers to functions in c, file pointer in c, file pointers in c

HTML Quizes

XML Quizes