Rechercher : dans
Par :

Pointeur c/c++

Dernière réponse le 3 nov 2007 à 22:41:18 mixtape, le 15 nov 2005 à 11:32:04 
 Signaler ce message aux modérateurs

Quel est la difference entre un pointeur *P et P* : l etoile qui se positionne apres et avant ????

Meilleures réponses pour « pointeur c/c++ » dans :
Les files en langage C VoirLes files - Premier Entré Premier Sorti Requis I. INTRODUCTION II. Définition III. La construction du prototype d'un élément de la file IV. Opérations sur les files A. Initialisation B. Insertion d'un élément dans la file C. Oter un...
Les pointeurs en langage C VoirDéfinition d'un pointeur Un pointeur est une variable contenant l'adresse d'une autre variable d'un type donné. La notion de pointeur fait souvent peur car il s'agit d'une technique de programmation très puissante, permettant de définir des...
Les objets en langage C++ VoirLa création d'objets En C++, il existe deux façons de créer des objets, c'est-à-dire d'instancier une classe : de façon statique de façon dynamique La création statique La création statique d'objets consiste à créer un objet en lui affectant un...
Introduction au langage C VoirPetite histoire du C Le langage C a été mis au point par D.Ritchie et B.W.Kernighan au début des années 70. Leur but était de permettre de développer un langage qui permettrait d'obtenir un système d'exploitation de type UNIX portable. D.Ritchie...

1

pom, le 15 nov 2005 à 15:08:39

Salut, j'espère ne pas être à côté de la plaque en te répondant

si je fais :

int * P;

(les espaces n'ont aucune importance) je dis que ma variable P est un pointeur vers un entier.

donc P contient l'adresse de l'entier vers lequel il pointe. Pour connaitre la valeur de cet entier tu fais :

*P


tu vois que dans les deux cas il est écrit " *P " mais un coup tu définis un pointeur, un autre coup tu regarde le contenu de l'objet pointé.

Si tu fais
P* toto;


ca veut dire que P est une classe et que tu dis que toto est un pointeur vers ta classe P. De même *toto est la valeur de l'objet pointé par toto

fais ceci :

#include<iostream>

int main()
{
int * p=NULL; // pour eviter d'avoir un pointeur fou on le met à NULL
int x=3;
p=&x; // p pointe vers la case mémoire de x

// affichage des adresses mémoires
std::cout<<p<<" "<<&x<<std::endl;

// affichage des valeurs des objets pointés
std::cout<<*p<<" "<<x<<std::endl;

*p=7;

// affichage des valeurs des objets pointés
std::cout<<*p<<" "<<x<<std::endl;

// -> x vaut maintenant 7 !!

return 0;
}

Répondre à pom

2

mixtape, le 15 nov 2005 à 21:52:39

Merci ;) ... mais autre chose .. vous pouvez m donner un exemple sur p* toto ....ca m aidra bien j croi

Répondre à mixtape

4

pom, le 16 nov 2005 à 09:32:52

Salut, voici un exemple P* toto;
J'ai donc dis dans le précédent post que P est un type (une classe), par exemple une classe Voiture (ou une struct)

typedef struc ma_Voiture{
unsigned int nb_portes;
char * marque;
} Voiture;

Voiture * v=NULL; (analogie avec P* toto)

v->nb_portes=5;
v->marque="Renault";

version sans les pointeurs :

Voiture v2;
v2.nb_portes=5;
v2.marque="Renault";

J'espère que c'est un peu plus clair...

Répondre à pom

3

mamiemando, le 16 nov 2005 à 00:37:18

Rappels sur les pointeurs

Je ne sais pas si ca va t'aider mais une declaration de pointeur ce lit de deux façons :

int *p

*p est un int
p est un int * (pointeur sur un entier).

Personnellement je trouve que pointeur, bien que ce soit parlant, occulte un peu ce qui se passe en réalité. En fait tous les pointeurs sans exception et -quel que soit leur type- sont une adresse mémoire, donc une valeur qui tient toujours 4 octets (il me semble que c'est 4), et ce complètement indépendamment de ce qui se trouve à cette adresse. Le type associé à un pointeur caractérise uniquement la manière dont on va interpréter ce qui est à cette adresse.

Bref, int *p=0x1234566 est une adresse.
A cette adresse se trouve la valeur de l'entier *p si le pointeur a été fabriqué correctement.

Tu noteras que tu déclares une adresse comme une variable classique donc
int * p=NULL; //l'adresse stockée dans p recoit l'adresse nulle

Rien ne t'empeche de changer le type d'un pointeur puisque c'est une adresse. Tu ne fais que changer la manière dont est interprété ce qui se trouve à cette adresse (cast).

Allocation mémoire

Bien entendu en déclarant un pointeur tu alloues la place nécessaire pour stocker l'adresses (quelques bits), mais encore faut il que cette adresse soit valide. Le role des malloc et calloc du C (et du new en c++) est justement d'allouer un espace memoire et de l'affecter à ton pointeur.

Tu noteras que malloc retourne un pointeur (void *) c'est à dire une adresse sans présumé de ce qui se trouve à cette adresse (un int * présume que ce qui s'y trouve est un int), d où le cast :
int * plop=(int *) malloc(sizeof(i));
//A partir de la la case memoire *plop qui fait la taille d'un int est allouée
//je peux donc ecrire dedans (sinon ça aurait fait une erreur de segmentation)
*plop=2;

Pointeurs de pointeurs, opérateurs * et &

Rien ne t'empêche de construire des adresses d'adresses (double pointeurs et ainsi de suite). Ainsi :


int *** plop3;
int ** plop2=*plop3; //adresse d'un pointeur de type int *
int *plop1= *plop2: //adresse d'un entier
int *plop1=**plop3;
int plop=*plop1


Comme tu le vois * permet de passer d'une adresse à la valeur stockée à cette adresse. mais le C propose l'opérateur réciproque (à savoir quel est l'adresse de ma variable). Ainsi :
plop3==&plop2
plop2==&plop1
plop1==&plop


       p                          *p
0x123456 ---------> 2
0x123456 <--------- 2
       &q                        q


A ce stade tu devrais commencer à maitriser les notations avec des * et des &.

Libérer la mémoire

Tu peux allouer de la mémoire avec des malloc ou des nex, mais quand tu n'as plus besoin de ces variables il faut les virer avec un free (en c) ou un delete (en c++)
P * plop = new P();
delete plop;

int * plop2 = (int *) malloc(sizeof(int));
free(plop2);

Les références (c++ seulement)

En c++ on travaille plutôt avec des références. Il faut voir une référence comme un pointeur, sauf que tout ce passe comme si on manipulait directement la variable (en terme de
int i=2;
int & k=i;
k=3; //i vaut désormais 2 car k e i sont liés par les liens sacré de la reference !
int * p =& i; // pas besoin d'allouer car i a été alloué par le int i=2;
*p=4; //i vaut désormais 4


Voilà si tu as des questions n'hésites pas ;-)
Bonne chance

Répondre à mamiemando

5

jojo, le 1 mai 2007 à 11:12:53

Salut!

je veux ecrire une fonction mirroir:

A savoir par exemple char*mirroir(char*string)

consiste a reverser un string. Comment puis je reussir avec la fonction strrev?

Répondre à jojo

6

 mamiemando, le 2 mai 2007 à 02:35:36

Merci d'ouvrir un nouveau post vu que ce problème n'a rien à voir avec le problème initial. La solution ;

#include <string.h>
#include <stdio.h>
#include <stdlib.h>

void strrev(const char *str1,char *str2){
    unsigned int i,n=strlen(str1);
    for(i=0;i<n;++i) str2[i] = str1[n-i-1];
}

int main(){
    const char *str1="tapir";
    char *str2 = (char*)malloc(strlen(str1)*sizeof(char));
    strrev(str1,str2);
    printf("%s --> %s\n",str1,str2);
    free(str2);
    return 0;
}

Donne :
(mando@aldur) (~) $ gcc -W -Wall plop.c
(mando@aldur) (~) $ ./a.out
tapir --> ripat

Bonne chance

Répondre à mamiemando
Collection CommentÇaMarche.net