// both buf_size and max_files are constconst unsigned buf_size = 512, max_files = 20;int staff_size = 27; // nonconstconst unsigned sz = get_size(); // const value not known until run timechar input_buffer[buf_size]; // ok: const variablestring fileTable[max_files + 1]; // ok: constant expressiondouble salaries[staff_size]; // error: non const variableint test_scores[get_size()]; // error: non const expressionint vals[sz]; // error: size not knownuntil run time

const unsigned array_size = 3;int ia[array_size] = {0, 1, 2};

int ia[] = {0, 1, 2}; // an array of dimension 3

const unsigned array_size = 5;// Equivalent to ia = {0, 1, 2, 0, 0}// ia[3] and ia[4] default initialized to 0int ia[array_size] = {0, 1, 2};// Equivalent to str_arr = {"hi", "bye", "", "", ""}// str_arr[2] through str_arr[4] default initialized to the empty stringstring str_arr[array_size] = {"hi", "bye"};

char ca1[] = {‘C‘, ‘+‘, ‘+‘}; // no nullchar ca2[] = {‘C‘, ‘+‘, ‘+‘, ‘\0‘}; // explicit nullchar ca3[] = "C++"; // null terminator added automatically

int ia[] = {0, 1, 2}; // ok: array of intsint ia2[](ia); // error: cannot initialize one arraywith anotherint main(){    const unsigned array_size = 3;    int ia3[array_size]; // ok: but elements are uninitialized!    ia3 = ia; // error: cannot assign one array toanother    return 0;}

int main(){    const size_t array_size = 10;    int ia[array_size]; // 10 ints, elements are uninitialized    // loop through array, assigning value of its index to each element    for (size_t ix = 0; ix != array_size; ++ix)        ia[ix] = ix;    return 0;}        

int main(){    const size_t array_size = 7;    int ia1[] = { 0, 1, 2, 3, 4, 5, 6 };    int ia2[array_size]; // local array, elementsuninitialized    // copy elements from ia1 into ia2    for (size_t ix = 0; ix != array_size; ++ix)        ia2[ix] = ia1[ix];    return 0;}

string s("hello world");string *sp = &s; // sp holds the address of s

vector<int> *pvec; // pvec can point to a vector<int>int *ip1, *ip2; // ip1 and ip2 can point to an intstring *pstring; // pstring can point to a stringdouble *dp; // dp can point to a double

string* ps; // legal but can be misleading

string* ps1,ps2;

int ival = 1024;int *pi = 0; // pi initialized to address no objectint *pi2 = & ival; // pi2 initialized to address of ivalint *pi3; // ok, but dangerous, pi3 is uninitializedpi = pi2; // pi and pi2 address the same object, e.g.ivalpi2 = 0; // pi2 now addresses no object

// cstdlib #defines NULL to 0int *pi = NULL; // ok: equivalent to int *pi = 0;

double dval;double *pd = &dval; // ok: initializer is address of a doubledouble *pd2 = pd; // ok: initializer is a pointer to doubleint *pi = pd; // error: types of pi and pd differpi = &dval; // error: attempt to assign address of a doubleto int *

double obj = 3.14;double *pd = &obj;// ok: void* can hold the address value of any data pointer typevoid *pv = &obj; // obj can be an object of any typepv = pd; // pd can be a pointer to any type

string s("hello world");string *sp = &s; // sp holds the address of scout <<*sp; // prints hello world

*sp = "goodbye"; // contents of s now changed

int ival = 1024, ival2 = 2048;int *pi = &ival, *pi2 = &ival2;pi = pi2; // pi now points to ival2

int &ri = ival, &ri2 = ival2;ri = ri2; // assigns ival2 to ival

int ival = 1024;int *pi = &ival; // pi points to an intint **ppi = π // ppi points to a pointer to int

cout << "The value of ival\n"    << "direct value: " << ival << "\n"    << "indirect value: " << *pi << "\n"    << "doubly indirect value: " << **ppi    << endl;

　　int ia[] = {0,2,4,6,8};　　int *ip = ia; // ip points to ia[0]

    ip = &ia[4]; // ip points to last element in ia

ip = ia; // ok: ip points to ia[0]int *ip2 = ip + 4; // ok: ip2 points to ia[4], the last elementin ia

ptrdiff_t n = ip2 - ip; // ok: distance between the pointers

int last = *(ia + 4); // ok: initializes last to 8, the valueof ia[4]

last = *ia + 4; // ok: last = 4, equivalent to ia[0]+4

int ia[] = {0,2,4,6,8};int i = ia[0]; // ia points to the first element in ia

int *p = &ia[2]; // ok: p points to the element indexed by2int j = p[1]; // ok: p[1] equivalent to *(p + 1),// p[1] is the same element as ia[3]int k = p[-2]; // ok: p[-2] is the same element as ia[0]

const size_t arr_size = 5;int arr[arr_size] = {1,2,3,4,5};int *p = arr; // ok: p points to arr[0]int *p2 = p + arr_size; // ok: p2 points one past the end ofarr// use caution -- do notdereference!

const size_t arr_sz = 5;int int_arr[arr_sz] = { 0, 1, 2, 3, 4 };// pbegin points to first element, pend points just after thelastfor (int *pbegin = int_arr, *pend = int_arr + arr_sz;pbegin != pend; ++pbegin)cout << *pbegin << ‘ ‘; // print the current element

const double *cptr; // cptr may point to a double that is const

const double pi = 3.14;double *ptr = π // error: ptr is a plain pointerconst double *cptr = π // ok: cptr is a pointer to const

const int universe = 42;const void *cpv = &universe; // ok: cpv is constvoid *pv = &universe; // error: universe is const

double dval = 3.14; // dval is a double; its value can be changedcptr = &dval; // ok: but can‘t change dval through cptr

dval = 3.14159; // dval is not const*cptr = 3.14159; // error: cptr is a pointer to constdouble *ptr = &dval; // ok: ptr points at non-const double*ptr = 2.72; // ok: ptr is plain pointercout << *cptr; // ok: prints 2.72

int errNumb = 0;int *const curErr = &errNumb; // curErr is a constant pointer

const double pi = 3.14159;// pi_ptr is const and points to a const objectconst double *const pi_ptr = π

char ca1[] = {‘C‘, ‘+‘, ‘+‘}; // no null, not C-style stringchar ca2[] = {‘C‘, ‘+‘, ‘+‘, ‘\0‘}; // explicit nullchar ca3[] = "C++"; // null terminator added automaticallyconst char *cp = "C++"; // null terminator added automaticallychar *cp1 = ca1; // points to first element of a array, but not C-style stringchar *cp2 = ca2; // points to first element of a null-terminated char array

const char *cp = "some value";while (*cp) {// do something to *cp++cp;}

char ca[] = {‘C‘, ‘+‘, ‘+‘}; // not null-terminatedcout << strlen(ca) << endl; // disaster: ca isn‘t null-terminated

// Dangerous: What happens if we miscalculate the size of largeStrchar largeStr[16 + 18 + 2]; // will hold cp1 a spaceand cp2strcpy(largeStr, cp1); // copies cp1 into largeStrstrcat(largeStr, " "); // adds a space at end of largeStrstrcat(largeStr, cp2); // concatenates cp2 to largeStr// prints A string example A different stringcout << largeStr << endl;

char largeStr[16 + 18 + 2]; // to hold cp1 a space and cp2strncpy(largeStr, cp1, 17); // size to copy includes the nullstrncat(largeStr, " ", 2); // pedantic, but a good habitstrncat(largeStr, cp2, 19); // adds at most 18 characters, plus a null

string largeStr = cp1; // initialize large Str as a copy of cp1largeStr += " "; // add space at end of largeStrlargeStr += cp2; // concatenate cp2 onto end of largeStr

// array of size 3, each element is an array of ints of size 4int ia[3][4];

int ia[3][4] = { /* 3 elements, each element is an array of size 4 */{0, 1, 2, 3} , /* initializers for row indexed by 0 */{4, 5, 6, 7} , /* initializers for row indexed by 1 */{8, 9, 10, 11} /* initializers for row indexed by 2 */};

// equivalent initialization without the optional nested braces foreach rowint ia[3][4] = {0,1,2,3,4,5,6,7,8,9,10,11};

const size_t rowSize = 3;const size_t colSize = 4;int ia [rowSize][colSize]; // 12 uninitialized elements// for each rowfor (size_t i = 0; i != rowSize; ++i)// for each column within the rowfor (size_t j = 0; j != colSize; ++j)// initialize to its positional indexia[i][j] = i * colSize + j;

int ia[3][4]; // array of size 3, each element is an array ofints of size 4int (*ip)[4] = ia; // ip points to an array of 4 intsip = &ia[2]; // ia[2] is an array of 4 ints

typedef int int_array[4];int_array *ip = ia;

for (int_array *p = ia; p != ia + 3; ++p)for (int *q = *p; q != *p + 4; ++q)cout << *q << endl;