--- title: "Pointers (C++) | Microsoft Docs" ms.custom: "" ms.date: "11/04/2016" ms.reviewer: "" ms.suite: "" ms.technology: - "cpp-language" ms.tgt_pltfrm: "" ms.topic: "language-reference" dev_langs: - "C++" helpviewer_keywords: - "declarators, pointers" - "declarations, pointers" - "pointers" - "pointers, declarations" ms.assetid: 595387c5-8e58-4670-848f-344c7caf985e caps.latest.revision: 14 author: "mikeblome" ms.author: "mblome" manager: "ghogen" translation.priority.ht: - "cs-cz" - "de-de" - "es-es" - "fr-fr" - "it-it" - "ja-jp" - "ko-kr" - "pl-pl" - "pt-br" - "ru-ru" - "tr-tr" - "zh-cn" - "zh-tw" --- # Pointers (C++) Pointers are declared using the following sequence. ``` [storage-class-specifiers] [cv-qualifiers] type-specifiers  [ms-modifier] declarator ; ``` where any valid pointer declarator may be used for `declarator`. The syntax for a simple pointer declarator is as follows: ``` * [cv-qualifiers] identifier [= expression] ``` 1. The declaration specifiers: - An optional storage class specifier. For more information, see [Specifiers](../cpp/specifiers.md). - An optional `const` or `volatile` keyword applying to the type of the object to be pointed to. - The type specifier: the name of a type representing the type of the object to be pointed to. 2. The declarator: - An optional Microsoft specific modifier. For more information, see [Microsoft-Specific Modifiers](../cpp/microsoft-specific-modifiers.md). - The `*` operator. - An optional `const` or `volatile` keyword applying to the pointer itself. - The identifier. - An optional initializer. The declarator for a pointer to function looks like this: ``` (* [cv-qualifiers] identifier )( argument-list ) [cv-qualifers] [exception specification] [= expression]; ``` - For an array of pointers, the syntax looks like this: ``` * identifier [ [ constant-expression ] ] ``` - Multiple declarators and their initializers may appear together in a single declaration in a comma separated list following the declaration specifier. A simple example of a pointer declaration is: ``` char *pch; ``` The preceding declaration specifies that `pch` points to an object of type `char`. A more complex example is ``` static unsigned int * const ptr; ``` The preceding declaration specifies that `ptr` is a constant pointer to an object of type `unsigned` `int` with static storage duration. The next example shows how multiple pointers are declared and initialized: ``` static int *p = &i, *q = &j; ``` In the preceding example, pointers p and q both point to objects of type `int` and are initialized to the addresses of i and j respectively. The storage class specifier `static` applies to both pointers. ## Example ``` // pointer.cpp // compile with: /EHsc #include int main() { int i = 1, j = 2; // local variables on the stack int *p; // a pointer may be assigned to "point to" the value of // another variable using the & (address of) operator p = & j; // since j was on the stack, this address will be somewhere // on the stack. Pointers are printed in hex format using // %p and conventionally marked with 0x. printf_s("0x%p\n", p); // The * (indirection operator) can be read as "the value // pointed to by". // Since p is pointing to j, this should print "2" printf_s("0x%p %d\n", p, *p); // changing j will change the result of the indirection // operator on p. j = 7; printf_s("0x%p %d\n", p, *p ); // The value of j can also be changed through the pointer // by making an assignment to the dereferenced pointer *p = 10; printf_s("j is %d\n", j); // j is now 10 // allocate memory on the heap for an integer, // initialize to 5 p = new int(5); // print the pointer and the object pointed to // the address will be somewhere on the heap printf_s("0x%p %d\n", p, *p); // free the memory pointed to by p delete p; // At this point, dereferencing p with *p would trigger // a runtime access violation. // Pointer arithmetic may be done with an array declared // on the stack or allocated on the heap with new. // The increment operator takes into account the size // of the objects pointed to. p = new int[5]; for (i = 0; i < 5; i++, p++) { *p = i * 10; printf_s("0x%p %d\n", p, *p); } // A common expression seen is dereferencing in combination // with increment or decrement operators, as shown here. // The indirection operator * takes precedence over the // increment operator ++. // These are particularly useful in manipulating char arrays. char s1[4] = "cat"; char s2[4] = "dog"; char* p1 = s1; char* p2 = s2; // the following is a string copy operation while (*p1++ = *p2++); // s2 was copied into s1, so now they are both equal to "dog" printf_s("%s %s", s1, s2); } ``` ```Output 0x0012FEC8 0x0012FEC8 2 0x0012FEC8 7 j is 10 0x00320850 5 0x00320850 0 0x00320854 10 0x00320858 20 0x0032085C 30 0x00320860 40 dog dog ``` ## Example Another example illustrates the use of pointers in data structures; in this case, a linked list. ``` // pointer_linkedlist.cpp // compile with: /EHsc #include using namespace std; struct NewNode { NewNode() : node(0){} int i; NewNode * node; }; void WalkList(NewNode * ptr) { if (ptr != 0) { int i = 1; while (ptr->node != 0 ) { cout << "node " << i++ << " = " << ptr->i << endl; ptr = ptr->node; } cout << "node " << i++ << " = " << ptr->i << endl; } } void AddNode(NewNode ** ptr) { NewNode * walker = 0; NewNode * MyNewNode = new NewNode; cout << "enter a number: " << endl; cin >> MyNewNode->i; if (*ptr == 0) *ptr = MyNewNode; else { walker = *ptr; while (walker->node != 0) walker = walker->node; walker->node = MyNewNode; } } int main() { char ans = ' '; NewNode * ptr = 0; do { cout << "a (add node) d (display list) q (quit)" << endl; cin >> ans; switch (ans) { case 'a': AddNode(&ptr); break; case 'd': WalkList(ptr); break; } } while (ans != 'q'); } ``` ```Output a 45 d a 789 d qa (add node) d (display list) q (quit) enter a number: a (add node) d (display list) q (quit) node 1 = 45 a (add node) d (display list) q (quit) enter a number: a (add node) d (display list) q (quit) node 1 = 45 node 2 = 789 a (add node) d (display list) q (quit) ``` ## See Also [Indirection Operator: *](../cpp/indirection-operator-star.md) [Address-of Operator: &](../cpp/address-of-operator-amp.md)