Элементы списка и списка, где хранятся?

Question

Учитывая этот кусок кода:

#include <list> 
(void) someFunction(void) { 
    list <int> l; 
    l.push_back(1); 
} 

• Где элементы списка хранятся? Стек? Heap?
• Как сделать, чтобы эмпирически проверить, что значения находятся в стеке или куче?
• Эта функция может возвращать список? Отредактировано Если я объявляю функцию как список, можно ли возвращать список функций без проблем?

Sample (возвращение список):

#include <list> 
list<int> someFunction(void) { 
    list <int> l; 
    l.push_back(1); 
} 

... 
l2 = someFunction(); 
l2.push_back(2); 

Answer 1

Где элементы списка хранятся? Стек? Heap?

Элементы списка хранятся в куче. Вы можете увидеть это после вашего отладчика вниз при вызове метода push_back. Легче всего это хранить объекты, а не тип POD, и записывать конструктор. Вам понадобится конструктор копирования, поскольку они будут скопированы. Распределение происходит с помощью распределителя аргументов шаблона, который вы можете указать или не указывая, он будет идти с распределением кучи по умолчанию.

Как я могу сделать, чтобы эмпирически проверить, что значения находятся в стеке или куче?

Вы можете проверить это с помощью push_back элементов из стека:

std::list<int> my_list; 
int a = 10; 
my_list.push_back(a); 
a = 11; 
assert(*my_list.begin() == 10); 

Эта функция может возвращает список?

В C++ существует два способа передачи данных по ссылке: по ссылке или по значению. Если вы функция выглядит так,

list<int> func() 
{ 
    list<int> res; 
    res.push_back(10); 
    return res; 
} 

тогда вы передаете список по значению, что означает, что компилятор будет вызывать конструктор копирования в списке, который также копирует все значения в списке. По возвращении функции после копирования списка будет вызываться деструктор списка «res», высвободив все его элементы.Однако, если вы сделаете это:

list<int>& func() 
{ 
     list<int> res; 
     res.push_back(10); 
     return res; 
} 

Вы код потерпит неудачу, как вы вернуть ссылку в свой список «Рес», который уже будет уничтожен в конце его объем, так что вы ссылка будет инвалид.

Проблема с первым решением может быть производительностью. Вы также можете сделать это без вызова конструктора копии, как это:

void func(list<int>& res) 
{ 
    res.push_back(10); 
} 

list<int> list_to_fill; 
func(list_to_fill); 

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

Answer 2

Где элементы списка хранятся? Стек? Heap?

Элементы, принадлежащие списку, обычно динамически распределяются так, что это будет в куче.

Эта функция может возвращать список?

Нет, он не может, вы объявили свою функцию с типом возврата типа void.

Как я могу сделать, чтобы эмпирически проверить, что значения находятся в стеке или куче?

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

Answer 3

Если вы изменили подпись функции, чтобы вернуть список, вы действительно можете вернуть список; однако компилятор сделает копию , а копия - той, которая будет получена вызывающим абонентом.

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

Сам список будет находиться в стеке, но элементы, содержащиеся внутри, будут находиться в куче. Список будет содержать указатели, которые он управляет за кулисами, чтобы вам вообще не пришлось беспокоиться о хранилище.

Answer 4

Некоторые из них могут варьироваться в зависимости от прихоти компилятора и/или автора библиотеки.

Как сейчас, существует довольно хороший шанс, что компилятор обнаружит, что результат создания и заполнения списка никогда не используется, поэтому он исключит всю функцию как мертвый код. Чтобы этого не произошло, вы можете (например) вернуть список вместо того, чтобы просто уничтожить его в конце функции.

Это только добавляет новые возможности. Большинство компиляторов реализуют оптимизацию возвращаемого значения (RVO) и оптимизацию с наименьшими возвращаемыми значениями (NRVO).Это в основном означает, что когда/если вы возвращаете значение (например, ваш объект list) вместо того, чтобы создавать объект в стеке и копировать его в пункт назначения при его возврате, компилятор генерирует код для генерации объекта, в котором он происходит назначается после возвращения. В этом случае вместо создания локальной функции функция просто получит скрытый указатель на место, где будет записываться результат.

A std::list обычно выделяет пространство для хранения данных, используя std::allocate. Однако вы можете указать другой распределитель для его использования. В этом случае пространство можно было бы разместить практически в любом месте.

Хотя это чаще встречается с другими (вроде) контейнерами, такими как std::string, также возможно (по крайней мере в некоторых случаях) хранить как минимум небольшой объем данных в самом объекте и выделять пространство в куче только тогда, когда/если это переполнение. Для обеспечения безопасности исключений существуют некоторые ограничения, но в случае list<int> это не должно быть проблемой. Например, первая десятка int s может быть сохранена в самом объекте list, и только когда/если вы добавите больше этого, оно выделит место в куче.

Answer 5

Функция возврата объявляется следующим образом: list<int> somefunc() {list<int> L; return L; }.

Проверьте эти значения с помощью list<int>::iterator.

Как это:

#include <iostream> 
#include <list> 
using namespace std; 


list<int> someReturnFunc(int listSize) 
{ 
    list<int> myList; 

    for (int g=0; g< listSize; g++) myList.push_back(g); 

    return myList; 
} 

int main() 
{ 
    list<int> yourList; 
    list<int>::iterator i; 

    yourList = someReturnFunc(15); 

    for(i=yourList.begin(); i != yourList.end(); ++i) cout << *i << " "; 

    cout << endl; 

    return 0; 

} 

Answer 6

Вы могли бы сделать это таким образом (до тех пор, как я понимаю вашу проблему)

#include <iostream> 
#include <list> 

using namespace std; 

list<int> & fun() 
{ 
    list<int> & temp = *(new list<int>); 
    temp.push_back(4); 
    // you can do other operations on the list 
    return temp; // you pass the reference, any list will not be destroyed neither copied. 
} 

int main() 
{ 
    list<int> & my_list = fun(); 

    cout << *(my_list.begin()) << endl; 
} 

Answer 7

Вы выбрали ответ неверен о 1 вещи ...

возвращающего список не называют Лист копировать конструктор.

list<int> func() 
{ 
    list<int> res; // &res returns 0x7fff183f0900 
    res.push_back(10); 
    return res; 
} 

list<int> l = func(); // &l also returns 0x7fff183f0900 (no copy) 

Вы можете дважды проверить это, напечатав & Рез в функции и & л вне функции.

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