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;
}

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

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