Printable View
As I continue to study the C++ language, I have arrived at a point of inevitability where the book author has decided to teach pointers, C-Style strings, and arrays.
The Author's advice is to avoid the use of pointers, C-Style strings, and arrays in favor of string, vector, and its iterator. I agree with this ideology.
My question is while the author discourages use, can I still rely on points, C-Style Strings, and arrays when they seem applicable?
Yes, if by "points" you mean "pointers".Quote:
Originally Posted by Imanuel
Yes, you can, and in some cases you will be required to use pointers to do certain things. For example, to do *dynamic memory allocation* where you allocate memory at runtime requires a pointer. When you get into inheritance you'll see other uses as well.
The only thing I will agree with the author on is that std::vector<T> and std::string may replace _most_ uses of arrays and strings. However, a vector is not logically an array. A vector is logically a sequence, according to the STL documentation, and an array does not necessarily represent a logical sequence. Thus, the tr1::array<T, N> class.
Tee hee:Quote:
Originally Posted by MacNilly
By design and in practice, a vector is an array with dynamic size, and insofar as an array "does not necessarily represent a logical sequence", a vector also need not represent a logical sequence. When making the choice between std::array and std::vector, the first thing that comes to mind is primarily whether I need the size to be fixed or dynamic.Quote:
Originally Posted by C++11 Clause 23.3.2.1 Paragraph 1 (part)
A vector is implemented as an array, and because of the requirements that operator[] be O(1) the only thing you can use is an array. But that's besides the point.Quote:
Originally Posted by laserlight
Actually it does. In terms of STL concepts, vector "is a model of" Forward Sequence. As far as the meaning of that goes, a vector is a sequence.Quote:
and insofar as an array "does not necessarily represent a logical sequence", a vector also need not represent a logical sequence.
True enough.Quote:
When making the choice between std::array and std::vector, the first thing that comes to mind is primarily whether I need the size to be fixed or dynamic.
In support of my argument (which is admittedly a fine-point), I offer this example.
In a std::vector, is it always true that every element 0 to size()-1, is a valid constructed object?
I say the answer is yes.
In a regular C++ array (not std::array<T,N>), is it true that each object is a valid constructed object? Not necessarily.
Is that a sequence? All the elements in the middle are undefined. Now maybe std::array<T,N> default-construct each element, thus making it a sequence. But I meant arrays in general.Code:int *foo = new int[100];
int[0] = 1;
int[99] = 100;
[EDIT]
Opps, I meant to use malloc(100 * sizeof(int)), not operator new. I say malloc because often a container will separate allocation of memory from object construction. I just think that to be a logical sequence, each element must be defined (as in constructed), in addition to the standard mathematical definition of a sequence.
[/EDIT]
You might want to take a look at the complexity requirements of std::deque and ask yourself if a typical std::deque implementation uses an internal array, or does it do a little more than that? :)Quote:
Originally Posted by MacNilly
What is your point? My objection to your statements in post #3 is really that I consider a vector to be a dynamic array, so the claim that "a vector is not logically an array" is ludicruous to me. Consequently, I object to your conclusion that std::array was introduced because a vector is always a sequence, whereas an array supposedly might not be a sequence.Quote:
Originally Posted by MacNilly
You have just shot yourself in the foot since I quoted the standard as clearly stating that std::array is a sequence container :)Quote:
Originally Posted by MacNilly
Let me assume that you used malloc, and that int[0] and int[99] should be foo[0] and foo[99], respectively.Quote:
Originally Posted by MacNilly
It depends on your point of view. Logically, that is not a sequence, because it is not intended to be interpreted as a sequence. But if you replaced with a std::vector<int>(100), it would still not be a logical sequence, because it is still not intended to be interpreted as a logical sequence.
This is what I mean by my statement that 'insofar as an array "does not necessarily represent a logical sequence", a vector also need not represent a logical sequence'. For example, an array can be used to implement a heap, and a heap is not a sequence. A vector can also be used to implement a heap, and that certainly does not make a heap a sequence.
The values of the elements are undefined. However, the objects exist, since they are of type int. You can validly assign to foo[50].Quote:
Originally Posted by MacNilly
If you used a non-POD class type, then the objects would not exist. However, you would also not have an array of objects. Rather, you would have a pool of memory for which you say, use placement new to create objects at desired locations.
As for your conclusion that std::array was introduced because a vector is always a sequence, whereas an array supposedly might not be a sequence: it must fall apart here, because you consciously reached for malloc instead of demonstrating with std::array, and in fact you explicitly excluded std::array.Quote:
Originally Posted by MacNilly