В чем разница между этими двумя классами?

Question

Ниже, я не Объявление my_ints в качестве указателя. Я не знаю, где будет выделена память. Пожалуйста, просветите меня здесь!

#include <iostream> 
#include <vector> 

class FieldStorage 
{ 
private: 
    std::vector<int> my_ints; 

public: 
    FieldStorage() 
    { 
     my_ints.push_back(1); 
     my_ints.push_back(2); 
    } 

    void displayAll() 
    { 
     for (int i = 0; i < my_ints.size(); i++) 
     { 
      std::cout << my_ints[i] << std::endl; 
     } 
    } 
}; 

И здесь, я объявляю поле my_ints как указатель:

#include <iostream> 
#include <vector> 

class FieldStorage 
{ 
private: 
    std::vector<int> *my_ints; 

public: 
    FieldStorage() 
    { 
     my_ints = new std::vector<int>(); 
     my_ints->push_back(1); 
     my_ints->push_back(2); 
    } 

    void displayAll() 
    { 
     for (int i = 0; i < my_ints->size(); i++) 
     { 
      std::cout << (*my_ints)[i] << std::endl; 
     } 
    } 

    ~FieldStorage() 
    { 
     delete my_ints; 
    } 
}; 

main() функцию для проверки:

int main() 
{ 
    FieldStorage obj; 
    obj.displayAll(); 
    return 0; 
} 

Оба производит один и тот же результат. Какая разница?

Answer 1

С точки зрения управления памятью эти два класса практически идентичны. Несколько других респондентов предположили, что существует разница между ними в том, что они выделяют хранилище в стеке и другие в куче, но это не обязательно верно, и даже в тех случаях, когда это правда, это ужасно вводит в заблуждение. В действительности, все, что отличается, - это где метаданные для vector; фактическое базовое хранилище в vector выделяется из кучи независимо.

Это немного сложно увидеть, потому что вы используете std::vector, поэтому конкретные детали реализации скрыты. Но в принципе, std::vector реализуется следующим образом:

template <class T> 
class vector { 
public: 
    vector() : mCapacity(0), mSize(0), mData(0) { } 
    ~vector() { if (mData) delete[] mData; } 
    ... 
protected: 
    int mCapacity; 
    int mSize; 
    T *mData; 
}; 

Как вы можете видеть, сам vector класс имеет только несколько членов - емкость, размер и указатель на динамически выделенный блок памяти, который будет хранить фактический содержимое вектора.

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

Во втором примере эти биты vector всегда выделены в кучу.

В обоих примерах фактическое мясоvector - его содержимое выделено из кучи, и вы не можете изменить это.

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

Answer 2

Вы должны освободить (чтобы предотвратить утечку памяти) память, выделенную для вектора во втором случае в деструкторе FieldStorage.

FieldStorage::~FieldStorage() 
{ 
    delete my_ints; 
} 

Answer 3

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

Answer 4

В первом примере объект выделяется в стеке.

Второй пример: объект выделяется в куче, а указатель на эту память хранится в стеке.

Answer 5

Как отметил Николай Голубев, вам нужно удалить вектор во втором случае.

Первый, возможно, построит более быстрый код, так как оптимизатор знает полный размер поля FieldStorage, включая вектор, и может выделять достаточно памяти в одном распределении для обоих.

Для вашей второй реализации требуется два отдельных распределения для построения объекта.

Answer 6

разница заключается в том, что вторая динамически распределяет вектор. Есть несколько отличий:

• вы должны освободить память, занятую векторный объектом (сам векторного объектом, а не объект хранится в векторе, так как он правильно обрабатывается вектор). вы должны использовать некоторый умный указатель, чтобы сохранить вектор или сделать (например, в деструкторе):

  delete my_ints;

• первый, вероятно, более эффективен, поскольку объект выделяется в стеке.

• доступ к методу вектора имеют различный синтаксис :)

Answer 7

В первом случае станд :: вектор кладется прямо в классе (и обрабатывает любое распределение памяти и освобождение его необходимо вырастить и сжать вектор и освободить память, когда ваш объект будет уничтожен, он абстрагирует управление памятью от вас, так что вам не придется с этим справляться). Во втором случае вы явно выделяете хранилище для std :: vector в кучу где-то и забываете когда-либо удалять его, поэтому ваша программа будет утечка памяти.

Answer 8

Я думаю, что вы действительно ищете разницу между Stack and the Heap.

Первый помещается в стек, а второй - в кучу.

Answer 9

Первая версия FieldStorage содержит вектор. Размер класса FieldStorage включает в себя достаточное количество байтов для хранения вектора. Когда вы создаете FieldStorage, вектор строится непосредственно перед тем, как будет выполнен конструктор FieldStorage. Когда FieldStorage разрушается, то и вектор.

Это не обязательно выделяет вектор в стеке; если вы куча-выделите объект FieldStorage, тогда пространство для вектора будет получено из этого распределения кучи, а не из стека. Если вы определяете глобальный объект FieldStorage, то пространство для вектора происходит не из ни стека, ни кучи, а скорее из пространства, предназначенного для глобальных объектов (например, раздел или .bss на некоторых платформах).

Обратите внимание, что вектор выполняет выделение кучи для хранения фактических данных, поэтому он может содержать только несколько указателей или указатель и пару длин, но он может содержать все, что ему требуется для выполнения STL-реализации вашего компилятора.

Вторая версия FieldStorage содержит указатель на вектор. Размер класса FieldStorage включает место для указателя на вектор, а не на фактический вектор. Вы выделяете хранилище для вектора, используя новое в теле конструктора FieldStorage, и вы уничтожаете это хранилище при уничтожении FieldStorage, потому что вы не определили деструктор, который удаляет вектор.

Answer 10

Размер объекта будет отличаться. Во втором случае Vector <> * занимает только размер указателя (4 байта на 32-битных машинах). В первом случае ваш объект будет больше.

Answer 11

Одно практическое отличие состоит в том, что в вашем втором примере вы никогда не выпускаете ни памяти для вектора, ни его содержимого (потому что вы его не удаляете и поэтому вызываете его деструктор).

Но первый пример автоматически уничтожит вектор (и освободит его содержимое) при уничтожении вашего объекта FieldStorage.