Access the elements of an Array
unsinged scores = {1, 2, 3, 4, 5, 6};
for ( auto i:scores){
cout << i << " ";
}
cout << endl;
Becuase the dimension is part of each array type. the system know how many elements are in scores.
Pointers and Arrays
In C++, pointers and array are closely intertwined. When we use an array, the compiler ordinarily convert the array to a pointer.
string nums[] = {"one", "two", "three"}; string *p = &nums[0]; // p points to the first element in nums
Arrays have a special property - in most places when we use an array, the comipler automatically substitutes a pointer to the first element.
string *p2 = nums; // equivalent to p2 = &nums[0]
In most expression, when we use an object of array type, we are really using a pointer to the first element in the array.
When we use an array as an initializer for a variable defined as auto, the deduced type is a pointer, not an array:
int ia[] = {0, 1, 2, 3, 4, 5}; auto ia2(ia); // ia is an int * that points to the first element in ia
which is equivalent to
auso ia2(&ia[0]);
Pointer in arrays have additional operations beyond basic pointers. Pointers to array elements support the same operations as iterators on vectors or strings.
int arr[] = {0, 2, 4, 6, 8}; int *p = arr; // p points to the first elemnt in arr ++p; // p points to arr[1]
When we add (or substract) an integral value to(or from) a pointer, the result is a new pointer. The new pointer points to the element the given number ahead the original pointer.
int arr[5] = {1, 2, 3, 4, 5}; int *p = arr; // equivalent to int *p = &arr[1] int *ip2 = p + 4; // ip2 points to arr[4], the last element in arr
Interaction between Dereference and Pointer Arithmetic
int ia[] = {0, 2, 4, 6, 8}; int last = *(ia + 4); // ok; initilize last to 8, the value of ia[4]
The expression*(ia + 4) calculate the address four elements past ia and dereference the resulting pointer. This expression is equivalent to writing ia[4].
last = *ia + 4; // ok; last 4. equivalent to ia[0] + 4
Subscripts and Pointers
When we substripts an array, we are really subscripting a pointer to an element in that array.
int i = ia[2]; // ia is converted to a pointer to the first element in ia. // ia[2] fetchs the elements to which (ia + 2) points int *p = ia; // p points to the first element in ia; i = *(p + 2) // equivalent to ia[2]
int *p = &ia[2]; // p points to the element indexed by 2 int j = p[1]; // p[1] is equivalent to *(p + 1). // p[1] is the same element as ia[3] int k = p[-2]; // p[-2] is the same element as ia[0]
The library types force the index used with a subscript to be an unsigned value. The built-in subscript operator does not. The index used with the built-in subscript operator can be negatie value.
C-style stirngs are not type. Instead, they are a convention for how to represent and use character strings. Strings that follow convertion are stored in character arrays and are null terminated(' ').
Although C++ supports C-style strings, they should not be used by C++ programs. C-style strings are a surpringly rich source of bus and are the root cause of many security problems.
The pointer passed to these routins must point to null-terminated arrays.
char ca[] = {'C', '+', '+'}; // not null-terminated cout << strlen(ca) << endl; // disaster; ca isn't null-terminated
In this case, ca is an array of char but is not null-terminated. The result is undefined. The most likely effect of this call is that strlen will keep looking through the memory that follows ca until it encounter a null character.
For most application, in additions to being safter, it is also more efficient to use library strings rather then C-style strings.
Mixing library strings and C-style strings
string s("hello world"); char *str = s; // error, cannot initialize a char * from a string const char *str = s.c_str(); // ok
If a program need continue uses the content of the array returned by c_str(); the program must copy the array return by c_str();
We cannot initilize a built-in array from another array. Nor can we initliaze an array from vector. However, we can use an array to initliaze a vector.
int int_arr[] = {1, 2, 3, 4, 5}; vector<int> ivect(begin(int_arr), end(int_arr));
Pointers and arrays are surprisingly error-prone.
Modern C++ programs should use vectors and iteractor instead of built-in arrays and pointers. and use strings rather then C-style based character strings.
Reference:
C++ Primer, Fifth Edition, 3.5. Arrays