Academic Tutorials



English | French | Portugese | Dutch | Italian
Google

Online

À la maison Codes sources E-Livres Téléchargements Nous contacter Au sujet de nous

HTML Tutorials
HTML Tutorial
XHTML Tutorial
CSS Tutorial
TCP/IP Tutorial
XML Tutorials
XML Tutorial
XSL Tutorial
XSLT Tutorial
DTD Tutorial
Schema Tutorial
XForms Tutorial
XSL-FO Tutorial
XML DOM Tutorial
XLink Tutorial
XQuery Tutorial
XPath Tutorial
XPointer Tutorial
RDF Tutorial
SOAP Tutorial
WSDL Tutorial
RSS Tutorial
WAP Tutorial
Web Services Tutorial
Browser Scripting
JavaScript Tutorial
VBScript Tutorial
AJAX Tutorial
DHTML Tutorial
HTML DOM Tutorial
WMLScript Tutorial
E4X Tutorial
Server Scripting
ASP Tutorial
PHP Tutorial
PERL Tutorial
SQL Tutorial
ADO Tutorial
.NET (dotnet)
Microsoft.Net
XML Web Services
ASP.Net
.Net Mobile
C# : C Sharp
ADO.NET
VB.NET
Multimedia
SVG Tutorial
Flash Tutorial
Media Tutorial
SMIL Tutorial
Web Building
Web Browsers
Web Hosting
W3C Tutorial
Web Building
Web Quality
Web Semantic
Web Careers
Java Tutorials
Java Tutorial
JSP Tutorial
Servlets Tutorial
Struts Tutorial
EJB Tutorial
JMS Tutorial
JMX Tutorial
Programming Langauges
C Tutorial
C++ Tutorial
Visual Basic Tutorial
Data Structures Using C
Soft Skills
Communication Skills
Time Management
Project Management
Team Work
Leadership Skills
Corporate Communication
Negotiation Skills


Pointers dans C
Previous Next




Quel est indicateur ?

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.

  1. Appel par la référence
  2. 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



Previous Next

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
HTML Quiz
XHTML Quiz
CSS Quiz
TCP/IP Quiz
XML Quizes
XML Quiz
XSL Quiz
XSLT Quiz
DTD Quiz
Schema Quiz
XForms Quiz
XSL-FO Quiz
XML DOM Quiz
XLink Quiz
XQuery Quiz
XPath Quiz
XPointer Quiz
RDF Quiz
SOAP Quiz
WSDL Quiz
RSS Quiz
WAP Quiz
Web Services Quiz
Browser Scripting Quizes
JavaScript Quiz
VBScript Quiz
AJAX Quiz
DHTML Quiz
HTML DOM Quiz
WMLScript Quiz
E4X Quiz
Server Scripting Quizes
ASP Quiz
PHP Quiz
PERL Quiz
SQL Quiz
ADO Quiz
.NET (dotnet) Quizes
Microsoft.Net Quiz
XML Web Services Quiz
ASP.Net Quiz
.Net Mobile Quiz
C# : C Sharp Quiz
ADO.NET Quiz
VB.NET Quiz
Multimedia Quizes
SVG Quiz
Flash Quiz
Media Quiz
SMIL Quiz
Web Building  Quizes
Web Browsers Quiz
Web Hosting Quiz
W3C Quiz
Web Building Quiz
Web Quality Quiz
Web Semantic Quiz
Web Careers Quiz
Java Quizes
Java Quiz
JSP Quiz
Servlets Quiz
Struts Quiz
EJB Quiz
JMS Quiz
JMX Quiz
Programming Langauges Quizes
C Quiz
C++ Quiz
Visual Basic Quiz
Data Structures Using C Quiz
Soft Skills Quizes
Communication Skills Quiz
Time Management Quiz
Project Management Quiz
Team Work Quiz
Leadership Skills Quiz
Corporate Communication Quiz
Negotiation Skills Quiz

Privacy Policy
Copyright © 2003-2008 Vyom Technosoft Pvt. Ltd., All Rights Reserved.