Классы и указатели, как они работают?

Question

Основная проблема заключается в создании динамического класса. Что я сделал:

ptr = new animal[2]; 

Я пытаюсь создать динамический массив размера 2, на который указывает указатель ptr. Проблема возникает, когда я пытаюсь эти операции:

ptr[0].setspeed(9); 
ptr++->setspeed(13); 

Я использую DDD (GDB) графический отладчик и когда я показываю PTR, я вижу только это указывает на один объект. Когда я пытаюсь установить скорость, первый, похоже, работает, но второй не будет (скорость по умолчанию равна 0). Печать только получает мусор.

Я не уверен, что происходит, пожалуйста, помогите.

Кроме того, когда я делаю:

ptr->print(); 

должен ли он печатать как для ptr[0] и ptr[1], или просто ptr[0]?

Кроме того, может кто-нибудь быстро нарисовать картину того, как выглядят ptr и новый динамический класс? То, как я это вижу, это ptr, указывающий на массив, размер массива два, каждый из которых имеет объект для животных.

#include <iostream> 
using namespace std; 

class animal 
{ 
    private: 
     int speed; 
     double position_x; 
     double position_y; 

    public: 
     animal() : speed(0), position_x(0), position_y(0) 
     { 
     } 

     animal (int v, double x, double y) 
     { 
      this->speed = v; 
      this->position_x = x;  
      this->position_y = y; 
     } 

     animal(const animal & g) 
     { 
      this->speed = g.speed; 
      this->position_x = g.position_x; 
      this->position_y = g.position_y; 
     } 

     ~animal(); 

     void print(); 

     int getspeed() { return this->speed; } 

     int getx() { return this->position_x; } 

     int gety() { return this->position_y; } 

     void setspeed(int s) { this->speed = s; } 
    }; 

    void animal::print() 
    { 
     cout << "speed: " << this->getspeed() << endl; 
     cout << "position_x: " << this->getx() << endl; 
     cout << "position_y: " << this->gety() << endl; 
    } 

    int main() 
    { 
     animal *ptr; 
     ptr = new animal; 
     ptr = new animal [2]; 

     ptr[0].setspeed(9); 
     ptr++->setspeed(13); 

     ptr->print(); 
     cout << ptr[0].getspeed() << endl; 
     cout << ptr[1].getspeed(); 

     return 0; 
    } 

Answer 1

Мой C++ ржавый, но вот что я думаю:

ptr++->setspeed(13); 

Это пост-инкремент. ptrпервый оценивается и затем с приращением. Это означает, что setspeed вызывается на исходное значение указателя.

Лично я считаю, что этот стиль кода неприемлем, и я бы уволил любого, кто это пишет. Трудно читать, и его нужно легко читать и понимать.

Answer 2

Вместо

ptr[0].setspeed(9); 
ptr++->setspeed(13); 

Вы могли бы использовать более интуитивным и даже более правильно

ptr[0].setspeed(9); 
ptr[1].setspeed(13); 

Когда вы делаете ++, вы изменяете значение PTR, поэтому он будет указывать на следующий элемент. Вы должны сохранить указатель на начало массива, чтобы впоследствии удалить его.

Кроме того, ptr ++ увеличивает указатель, но возвращает значение old. Возможно, вы хотели (++ ptr) -> setspeed (13), который будет увеличивать и использовать значение в остальной части выражения.

Что касается вашего другого вопроса, ptr->print() - это то же самое, что и ptr[0].print(), а (ptr+1)->print() - это то же самое, что и ptr[1].print(). Нет встроенного синтаксиса для вызова print() для всех элементов.

Answer 3

Хорошо, кто-то указал the memory leak issue вам уже.

Итак, вы выделили массив из двух животных (ptr = new animal [2];) и сохранили указатель на первый в ptr.

+----------+----------+ 
| speed: 0 | speed: 0 | 
+----------+----------+ 
    ^
    | 
    | 
    ptr 

_{(я не обращая внимания на position_x и position_y, ради пространства)}

Затем вы устанавливаете скорость первого до 9 (ptr[0].setspeed(9);):

+----------+----------+ 
| speed: 9 | speed: 0 | 
+----------+----------+ 
    ^
    | 
    | 
    ptr 

Тогда вы делаете что-то очень странное.

ptr++->setspeed(13); 

Зачем вы это делаете, я не знаю. Не делай этого. Я не шучу. Я могу понять, что означает этот код, но я бы никогда не написал ничего подобного. Он служит только для того, чтобы посеять путаницу.

Но давайте притворимся, что это разумная вещь, чтобы сделать какое-то время ... ptr++ увеличивает указатель и возвращает старое значение.

+----------+----------+ 
| speed: 9 | speed: 0 | 
+----------+----------+ 
    ^  ^
     |   | 
     |   | 
    result  ptr 
    of ptr++ 

... а затем она устанавливает скорость животного, на который указывает, что результат до 13.

+-----------+----------+ 
| speed: 13 | speed: 0 | 
+-----------+----------+ 
    ^  ^
     |   | 
     |   | 
    result  ptr 
    of ptr++ 

Наконец, ptr->print() печатает животного указываемого ptr, который является второй один.

Answer 4

Если оператор ++ после переменной (ptr ++), он сначала выполняет оценку, а затем и приращение. Это означает, что это заявление,

ptr++->setspeed(13); 

работает как

ptr->setspeed(13) // ptr point to animal[0] 
ptr++    // ptr point to anima[1] after this statement 

И ++ ptr-> SetSpeed ​​(13) будет работать в обратном направлении.

Теперь вы можете видеть, где проблема. Фактически вы вызываете setpeed (13) на животном [0] и печать вызова() на животном [1].