初学者C ++程序员，对动态数组感到困惑

Question

I am trying to create a class analogous to the built-in vector class in C++. I have tried to follow all the instructions in Walter Savitche's textbook, but just can't get it to work properly.

The code was written using the Code::Blocks IDE and compiled using the gcc compiler.

The thing I think I'm missing is the relationship between array parameters and a pointer that points to an array. This is what I understand about normal variables:

int *p1, *p2, *p3, *p4, a;
a = 5; // variable  of type int with value 5
p1 = &a; // p1 now points to the value 5
p2 = p1; // p2 now also points to the value of a
p3 = new int; // p3 points to an anonamous variable of type int with undefined value
*p3 = *p1 // value of variable changed to the value of a, namely 5, but doesn't point to a
p4 = new int; // p4 points to an anonamous variable of type int with undefined value
*p4 = 5; // value of variable changed to  5
p4 = p1 // p4 now also points to the value of a

This is what I essentially don't understand about arrays and pointers that point to arrays

int *p1, *p2, *p3, *p4, a[3] = {4, 5, 6}; // a points to the first indexed element of the array, namely 4
p1 = a; // p1 points to the exactly the same thing as a
p2 = new int[3]; // p2 points to an array of base type int with undefined values
p2[0] = 8; // is this the correct usage? is p2 "dereferenced" 
p2[1] = 9;
p2[2] = 10;
p2[2] = p1[2]; // again is this correct? is the third element of the array pointed to by p2 now equal to 6?
*p3 = a // what does this mean?
p4 = new int[4]; // p4 points to an array of base type int with undefined values
p4[0] = p2[0]; 
p4[1] = p2[1];
p4[2] = p2[2];
p4[3] = 3
p2 = p4 // p2 now points to p4, but what happens to the array p2 was pointing to?
delete [] p2; // does this destroy the pointer and the array it is pointing to or just one or the other?

For completeness sake my class is defined as follows:

class VectorDouble
{
public:
    // constructors
    VectorDouble(); // default constructor
    VectorDouble(int init_count); // user specified
    VectorDouble(const VectorDouble& vd_object); // copy constructor
    // destructor
    ~VectorDouble();
    // accessors
    int capacity_vd(); // get max_count
    int size_vd(); // get amt_count
    double value_at(int index); // get value of "value" at index i
    // mutators
    void push_back_vd(double put_at_end); // insert new element at end of "value"
    void reserve_vd(int incr_capacity); // set max_count
    void resize_vd(int incr_size); // set amt_count
    void change_value_at(double d, int index); // set value of "value" at index i
    // overloaded =
    void operator =(const VectorDouble& vd_object_rhs);
    // other
    friend bool operator ==(VectorDouble vd_object1, VectorDouble vd_object2);
private:
    double *value; // pointer that points to array of type double
    int max_count; // the memory allocated to the array
    int amt_count; // the amount of memory in use
};

And the troublesome function is:

void VectorDouble::push_back_vd(double put_at_end)
{
    double *temp;
    if(amt_count == max_count)
        max_count += 1;
    temp = new double[max_count];
    for(int i = 0; i < amt_count; i++)
        temp[i] = value[i];
    amt_count += 1;
    temp[amt_count] = put_at_end;
    value = temp;
}

The member function just seems to insert 0.0 instead of the user input, I have no idea why...

In main:

VectorDouble vec1(10);
    double dd;

    cout << "Enter 3 doubles to vec1:\n";
    for(int i = 0; i < 3; i++)
    {
        cout << i << ": ";
        cin >> dd;
        vec1.push_back_vd(dd);
    }

    cout << "The variables you entered were:\n";
    for(int i = 0; i < 3; i++)
        cout << i << ": " << vec1.value_at(i) << endl;

I enter:

12.5 16.8 15.2

I get back:

0 0 0

I fixed it! Only problem is that the mistake was exceedinly simple. Sorry to waste everybodies time, but thanks to all, I did learn quite a lot!

The mistake was my placement of amt_count += 1; , I'm used to arrays indexed from 1 not zero (I have done a lot of coding in the R language). The corrected code with the memoery leak taken care of is:

void VectorDouble::push_back_vd(double put_at_end)
{
    double *temp;
    if(amt_count == max_count)
        max_count += 1;
    temp = new double[max_count];
    for(int i = 0; i < amt_count; i++)
        temp[i] = value[i];
    temp[amt_count] = put_at_end;
    amt_count += 1;
    delete [] value;
    value = temp;
}

Answer 1

This is what I understand about normal variables

All correct, with the caveat that I'd avoid the terminology "points to the value x "; you're pointing to the object , which in turn has value x .

This is what I essentially don't understand about arrays and pointers that point to arrays

You're confusing pointers with arrays. In int a[3] , a is an array. It is not a pointer. It is an array.

*p3 = a isn't valid, so it means nothing.

p2 now points to p4, but what happens to the array p2 was pointing to?

You've leaked it.

// does this destroy the pointer and the array it is pointing to or just one or the other?

It destroys the thing you new 'd, that the pointer is pointing to. ie the array

Otherwise all correct.

---

As for your vector implementation, the main problem is that temp[amt_count] is an overflow because you've already incremented amt_count . Also, vector implementations typically grow exponentially rather than on-demand. Finally, you're leaking the previous storage.

Answer 2

Using different terminology might help you:

A pointer is just an ordinary variable. Instead of holding an integer, a float, a double, etc., it holds a memory address. Consider the following:

int* p = nullptr; // p has the value "nullptr" or null memory address
int i = 5;        // i has value 5

p = &i;           // p now has the value of the address of i

The ampersand gets the address of a variable.

An asterisk dereferences a pointer; that is it will get the value stored in the memory address the pointer holds:

cout << *p << endl; // Prints whatever is stored in the memory address of i; 5

As for your vector implementation, try moving this line amt_count += 1; to below this line: temp[amt_count] = put_at_end; , as you're trying to access beyond the end of your array.

---

Most of your understanding is correct. But...

a[3] = {4, 5, 6}; // a points to the first indexed element of the array, namely 4

Although arrays and pointers can be indexed and treated in a similar fashion, they are different, and their differences can lead to some sneaky bugs; so be careful with this statement.

*p3 = a // what does this mean?

This is invalid. Your types don't match: *p3 is an integer, a is an array.

p2 = p4 // p2 now points to p4, but what happens to the array p2 was pointing to?

The array p2 was pointing to is now leaked memory. This is bad.

delete [] p2; // does this destroy the pointer and the array it is pointing to or just one or the other?

The value of the pointer does not change. However, the memory it points to is deallocated, so dereferencing it will give you undefined results. It's best to set p2 = nullptr; after deleting it.

This answer might help with your understanding of arrays and accessing their elements.

Answer 3

Your function is really wrong...

void VectorDouble::push_back_vd(double put_at_end)
{
    double *temp;
    if(amt_count == max_count)
        max_count += 1;
    temp = new double[max_count];
    for(int i = 0; i < amt_count; i++)
        temp[i] = value[i];
    amt_count += 1;
    temp[amt_count] = put_at_end;
    value = temp;
}

Notice that in each call you allocate new array (even if there's still space), copy everything in it and leak memory (old array)...

Here is a slightly corrected version, but it's not guaranteed to be completely OK (;

void VectorDouble::push_back_vd(double put_at_end)
{
    if(amt_count == max_count)
    {
        max_count += 1;
        double *temp = new double[max_count];
        for(int i = 0; i < amt_count; i++)
            temp[i] = value[i];
        delete[] value;
        value = temp;
    }
    value[amt_count] = put_at_end;
    amt_count += 1;
}

Answer 4

"p2 now points to p4, but what happens to the array p2 was pointing to?"

It is 'leaked', this means its still allocated but there is no way to reach it anymore. If you keep doing this is the same program your memory size will keep growing

Other languages (Java, c#,...) have 'garbage collectors' that detect when this happens and will free the memory automatically

C++ solution to this problem is to never user naked arrays and pointers. Instead you use std::vector and std::shared_ptr; these will clean up for you