Làm thế nào để có được một phần tử nhất định trong một danh sách, đã cho vị trí?

Vì vậy, tôi có một danh sách:

list<Object> myList;
myList.push_back(Object myObject);

Tôi không chắc nhưng tôi tự tin rằng đây sẽ là phần tử "0" trong mảng. Có bất kỳ chức năng nào tôi có thể sử dụng sẽ trả về "myObject" không?

Object copy = myList.find_element(0);

?

Nếu bạn thường xuyên cần truy cập phần tử thứ N của một chuỗi, std::listđược triển khai dưới dạng danh sách được liên kết kép, có lẽ không phải là lựa chọn phù hợp. std::vectorhoặc std::dequecó thể sẽ tốt hơn.

Điều đó nói rằng, bạn có thể nhận được một trình lặp đến phần tử thứ N bằng cách sử dụng std::advance:

std::list<Object> l;
// add elements to list 'l'...

unsigned N = /* index of the element you want to retrieve */;
if (l.size() > N)
{
    std::list<Object>::iterator it = l.begin();
    std::advance(it, N);
    // 'it' points to the element at index 'N'
}

Đối với một vùng chứa không cung cấp quyền truy cập ngẫu nhiên, chẳng hạn như std::list, std::advancecác cuộc gọi operator++vào Nlần lặp lại . Ngoài ra, nếu việc triển khai Thư viện chuẩn của bạn cung cấp nó, bạn có thể gọi std::next:

if (l.size() > N)
{
    std::list<Object>::iterator it = std::next(l.begin(), N);
}

std::nextlà kết thúc một cách hiệu quả một lời gọi đến std::advance, giúp dễ dàng tăng Nthời gian trình lặp với ít dòng mã hơn và ít biến có thể thay đổi hơn. std::nextđã được thêm vào C ++ 11.

std::listkhông cung cấp bất kỳ chức năng nào để lấy phần tử được cung cấp một chỉ mục. Bạn có thể cố gắng lấy nó bằng cách viết một số mã, mà tôi không khuyên bạn nên sử dụng, vì điều đó sẽ không hiệu quả nếu bạn thường xuyên phải làm như vậy.

Những gì bạn cần là: std::vector. Sử dụng nó như:

std::vector<Object> objects;
objects.push_back(myObject);

Object const & x = objects[0];    //index isn't checked
Object const & y = objects.at(0); //index is checked 

std::list<Object> l; 
std::list<Object>::iterator ptr;
int i;

for( i = 0 , ptr = l.begin() ; i < N && ptr != l.end() ; i++ , ptr++ );

if( ptr == l.end() ) {
    // list too short  
} else {
    // 'ptr' points to N-th element of list
}

Có thể không phải là cách hiệu quả nhất. Nhưng bạn có thể chuyển đổi danh sách thành một vector.

#include <list>
#include <vector>

list<Object> myList;

vector<Object> myVector(myList.begin(), myList.end());

Sau đó, truy cập vector bằng toán tử [x].

auto x = MyVector[0];

Bạn có thể đặt nó trong một hàm trợ giúp:

#include <memory>
#include <vector>
#include <list>

template<class T>
shared_ptr<vector<T>> 
ListToVector(list<T> List) {
shared_ptr<vector<T>> Vector {
        new vector<string>(List.begin(), List.end()) }
return Vector;
}

Sau đó, sử dụng funciton trợ giúp như thế này:

auto MyVector = ListToVector(Object);
auto x = MyVector[0];