Avantages des pointeurs?

Votre mis en évidence la règle est très sage. Il va vous garder hors de l'ennui, mais tôt ou tard, vous avez à apprendre les pointeurs.

Alors pourquoi voulons-nous utiliser des pointeurs?

Dire que j'ai ouvert un fichier texte et de le lire en une gigantesque chaîne de caractères. Je ne peux pas vous passer le géant de la chaîne de valeur, car il est trop gros pour tenir sur la pile (disons de 10 mo). Si je vous dis où la chaîne est et de dire "regardez-vous là-bas à ma chaîne".

Un tableau est un pointeur ( enfin presque ).

int[] et int* sont légèrement différents, mais interchangeables pour la plupart.

int[] i = new int[5]; //garbage data
int* j = new int[5]   //more garbage data but does the same thing
std::cout << i[3] == i + 3 * sizeof(int); //different syntax for the same thing

Une utilisation plus poussée de pointeurs qui est extrêmement utile est l'utilisation de pointeurs de fonction. En C et C++ les fonctions ne sont pas de première classe, types de données, mais les pointeurs sont. De sorte que vous pouvez passer un pointeur à une fonction que vous souhaitez appelé et ils peuvent le faire.

J'espère que ça aide, mais plus que probablement va être source de confusion.

Venant de Java, vous aurez une perspective légèrement différente de ce qui est présenté dans le K&R (K&R de ne pas supposer que le lecteur sait tout autre langage de programmation moderne).

Un pointeur en C est un peu plus capable de la version de référence en Java. Vous pouvez voir cette similitude par le biais de l'exception Java nommé NullPointerException. Un aspect important des pointeurs en C est que vous pouvez changement ce qu'ils point par incrémentation et de décrémentation.

En C, vous pouvez stocker un tas de choses en mémoire dans un tableau, et vous savez qu'ils sont assis côte à côte les uns des autres dans la mémoire. Si vous avez un pointeur sur l'un d'entre eux, vous pouvez faire que pointer à la "prochaine" de l'un par l'incrémentation. Par exemple:

int a[5];

int *p = a; //make p point to a[0]
for (int i = 0; i < 5; i++) {
    printf("element %d is %d\n", i, *p);
    p++; //make `p` point to the next element
}

Le code ci-dessus utilise le pointeur p à point pour chaque élément dans le tableau a dans l'ordre, et de les imprimer.

^{(Note: Le code ci-dessus est expositoire exemple seulement, et vous ne serait pas l'habitude d'écrire une boucle simple de cette façon. Il serait plus facile d'accéder aux éléments du tableau comme a[i]et ne pas utiliser un pointeur).}

Rappelez-vous que C (et le K&R livre) très ancienne, sans doute plus que tout ce que vous avez appris avant (certainement âges âgés de plus de Java). Les pointeurs ne sont pas une caractéristique supplémentaire de C, ils sont très basique, en partie de la façon dont les ordinateurs fonctionnent.

Pointeur de la théorie n'est pas particulièrement difficile à maîtriser, seulement qu'ils sont très puissants donc une erreur sera probablement planter votre application, et les compilateurs ont un moment difficile essayer de l'attraper pointeur liées à des erreurs. L'une des grandes nouveautés de Java, a été avoir "presque" autant de pouvoir que C sans pointeurs.

Donc, à mon avis, essayer de rédiger C en évitant les pointeurs, c'est comme essayer de monter un vélo sans pédale. Oui, c'est faisable mais vous aurez à travailler deux fois plus dur.

Considérant que vous êtes en provenance d'un Java de fond, voici le moyen le plus simple pour obtenir votre tête autour de ce qui utilisent des pointeurs ont.

Disons que vous avez une classe comme ça en Java:

public class MyClass {
    private int myValue;

    public int getMyValue() { return myValue; }
    public void setMyValue(int value) { myValue = value; }
}

Ici est votre fonction principale, qui crée un de vos objets et appelle une fonction.

public static void Main(String[] args) {
    MyClass myInstance = new MyClass();

    myInstance.setMyValue(1);
    System.out.printLn(myInstance.getMyValue()); //prints 1

    DoSomething(myInstance);
    System.out.printLn(myInstance.getMyValue()); //prints 2
}

public static void DoSomething(MyClass instance) {
    instance.setMyValue(2);
}

La myInstance variable déclarée à l' Main est une référence. C'est essentiellement une poignée de la JVM utilise pour garder un œil sur votre instance de l'objet. Maintenant, laissez-nous faire la même chose en C.

typedef struct _MyClass
{
    int myValue;
} MyClass;

void DoSomething(MyClass *);

int main()
{
    MyClass myInstance;

    myInstance.myValue = 1;
    printf("i", myInstance.myValue); //prints 1

    MyClass *myPointer = &myInstance; //creates a pointer to the address of myInstance

    DoSomething(myPointer);
    printf("i", myInstance.myValue); //prints 2

    return 0;
}

void DoSomething(MyClass *instance)
{
    instance->myValue = 2;
}

Bien sûr, les pointeurs sont beaucoup plus souple en C, mais c'est l'essentiel de la façon dont ils fonctionnent dans une Java.

Dans cet exemple:

int f1(int i); 
f1(x);

le paramètre i est passé par valeur, donc la fonction f1 ne pouvait pas changer la valeur de la variable x de l'appelant.

Mais dans ce cas:

int f2(int* i);
int x;
int* px = &x;
f2(px);

Ici, nous avons toujours passer px paramètre par valeur, mais dans le même temps que nous passons x par refference!. Donc, si le destinataire de l'appel (f2) va changer sa int* i elle n'aura aucun effet sur px en l'appelant. Cependant, en changeant *i le destinataire de l'appel permet de changer la valeur de x en l'appelant.

Pointeurs de rendre possible la dynamique de répartition de code donné des conditions ou de l'état du programme. Une façon simple de compréhension de ce concept est de penser à une structure de l'arbre où chaque nœud représente un appel de fonction, variable, ou un pointeur vers un sous-niveau du nœud. Une fois que vous comprenez cela, vous, puis utiliser des pointeurs pour pointer vers établie emplacements de mémoire que le programme peut faire référence à la volonté de comprendre la intitial de l'état, et donc la première de déréférencement et de l'offset. Ensuite, chaque nœud peut contenir son propre pointeurs afin de mieux comprendre l'état dans lequel un autre déréférencement peut avoir lieu, une fonction peut être appelée, ou une valeur de main.

Bien sûr, c'est juste une manière de visualiser comment les pointeurs peuvent être utilisés depuis un pointeur n'est rien de plus qu'une adresse d'un emplacement mémoire. Vous pouvez également utiliser des pointeurs pour la transmission de message, la fonction virtuelle appels, la collecte des ordures, etc. En fait, j'ai utilisé pour recréer style c++ virtuel des appels de fonction. Le résultat est que le c fonction virtuelle et c++ des fonctions virtuelles exécuter exactement à la même vitesse. Cependant l'implémentation c était beaucoup plus petit en taille (66% de moins en KO) et un peu plus portable. Mais la réplication des caractéristiques d'autres langues en C ne sera pas toujours avantageux, évidemment, b/c d'autres langues pourraient être mieux équipés pour recueillir de l'information que le compilateur peut utiliser pour l'optimisation de la structure de données.

En résumé, il ya beaucoup qui peut être fait avec des pointeurs. Le langage C et les pointeurs sont dévalué de nos jours b/c plus un langage de haut niveau sont équipées avec le plus souvent des structures de données /implémentations que vous auriez eu à construire sur votre propre avec l'utilisation de pointeurs. Mais il y a toujours des moments où un programmeur peut-être besoin de mettre en œuvre un complexe de routine et dans ce cas, de savoir comment utiliser les pointeurs est une très bonne chose.