cách khởi tạo 'const std :: vector <T>' giống như mảng ac

Có cách nào hay để tạo và khởi tạo một const std::vector<const T>like const T a[] = { ... }cho một số giá trị cố định (và nhỏ) không?
Tôi cần thường xuyên gọi một hàm mong đợi a vector<T>, nhưng những giá trị này sẽ không bao giờ thay đổi trong trường hợp của tôi.

Về nguyên tắc, tôi nghĩ về một cái gì đó như

namespace {
  const std::vector<const T> v(??);
}

vì v sẽ không được sử dụng bên ngoài đơn vị biên dịch này.

Bạn phải đợi C ++ 0x hoặc sử dụng thứ gì đó như Boost.Assign để làm điều đó.

ví dụ:

#include <boost/assign/std/vector.hpp>
using namespace boost::assign; // bring 'operator+=()' into scope

vector<int> v;
v += 1,2,3,4,5;

cho C ++ 11:

vector<int> luggage_combo = { 1, 2, 3, 4, 5 };

Nếu bạn đang hỏi làm thế nào để khởi tạo một vectơ const để nó có nội dung thú vị, thì câu trả lời có thể là sử dụng hàm tạo bản sao. Đầu tiên, bạn điền một cách chăm chỉ vào một vectơ, sau đó bạn tạo vectơ const mới từ nó. Hoặc bạn có thể sử dụng vector<InputIterator>(InputIterator, InputIterator)mẫu phương thức khởi tạo để khởi tạo từ một số loại vùng chứa hoặc mảng khác. Nếu một mảng, thì mảng đó có thể đã được xác định bằng danh sách khởi tạo.

Một cái gì đó như thế này hy vọng gần với những gì bạn muốn:

const T ra[3] = {t1, t2, t3};
const vector<const T> v(ra, ra+3);

Nếu bạn đang hỏi làm thế nào để truyền một vectơ const vào một hàm nhận một vectơ thì câu trả lời là:

• bạn không thể, vì hàm có thể thay đổi vectơ và đối tượng / tham chiếu của bạn là const. Tạo một bản sao không phải const của bản gốc và chuyển nó vào.

hoặc là

• sử dụng const_castđể loại bỏ hằng số để chuyển nó vào một hàm nhận một vectơ không phải const nhưng mà bạn tình cờ biết sẽ không sửa đổi vectơ.

Cái thứ hai là một trong những thứ, hoàn toàn đúng, khiến bất cứ ai nhìn thấy nó sẽ đưa ra nhận xét về kính bảo hộ và thực tế là họ không làm gì cả. Nó chính xác const_castlà để làm gì , nhưng có một lập luận hợp lý mạnh mẽ nói rằng nếu bạn cần const_cast, bạn đã thua.

Thực hiện cả hai điều đó (tạo một vectơ const từ một vectơ không phải const bằng hàm tạo bản sao, và sau đó loại bỏ hằng số) chắc chắn là sai - bạn nên sử dụng một vectơ không phải const. Vì vậy, hãy chọn nhiều nhất một trong số này để làm ...

[ Chỉnh sửa: chỉ nhận thấy rằng bạn đang nói về sự khác biệt giữa vector<T>và const vector<const T>. Thật không may trong STL, vector<const T>và vector<T>là các loại hoàn toàn không liên quan, và cách duy nhất để chuyển đổi giữa chúng là bằng cách sao chép. Đây là sự khác biệt giữa vectơ và mảng - a T**có thể được chuyển đổi âm thầm và an toàn thành const T *const *]

Cách ngắn và bẩn (tương tự như của Boost list_of())

#include <iostream>
#include <vector>
#include <iterator>
#include <algorithm>
using namespace std;

template <typename T>
struct vlist_of : public vector<T> {
    vlist_of(const T& t) {
        (*this)(t);
    }
    vlist_of& operator()(const T& t) {
        this->push_back(t);
        return *this;
    }
};

int main() {
    const vector<int> v = vlist_of<int>(1)(2)(3)(4)(5);
    copy(v.begin(), v.end(), ostream_iterator<int>(cout, "\n"));
}

Bây giờ, C ++ 11 có danh sách trình khởi tạo, vì vậy bạn không cần phải làm theo cách đó hoặc thậm chí sử dụng Boost. Tuy nhiên, như một ví dụ, bạn có thể làm điều trên trong C ++ 11 hiệu quả hơn như sau:

    #include <iostream>
    #include <vector>
    #include <utility>
    #include <ostream>
    using namespace std;

    template <typename T>
    struct vlist_of : public vector<T> {
        vlist_of(T&& t) {
            (*this)(move(t));
        }
        vlist_of& operator()(T&& t) {
            this->push_back(move(t));
            return *this;
        }
    };

    int main() {
        const vector<int> v = vlist_of<int>(1)(2)(3)(4)(5);
        for (const auto& i: v) {
            cout << i << endl;
        }
    }

Tuy nhiên, nó vẫn không hiệu quả bằng việc sử dụng danh sách trình khởi tạo C ++ 11 vì không có operator=(vlist_of&&)định nghĩa cho vector.

Cách của tjohns20 được sửa đổi như sau có thể là một c ++ 11 tốt hơn vlist_of:

#include <iostream>
#include <vector>
#include <utility>
using namespace std;

template <typename T>
class vlist_of {
    public:
        vlist_of(T&& r) {
            (*this)(move(r));
        }
        vlist_of& operator()(T&& r) {
            v.push_back(move(r));
            return *this;
        }
        vector<T>&& operator()() {
            return move(v);
        }
    private:
        vector<T> v;
    
};

int main() {
    const auto v = vlist_of<int>(1)(2)(3)(4)(5)();
    for (const auto& i : v) {
        cout << i << endl;
    }
    
}

Như những người khác đã nói, bạn không thể init một vectơ giống như cách bạn có thể bắt một mảng kiểu C, trừ khi bạn cung cấp con trỏ cho một mảng nguồn. Nhưng trong trường hợp đó, nếu vectơ của bạn là một hằng số toàn cục, tại sao không chỉ sử dụng một mảng kiểu C cũ để thay thế?

const int MyInts[] = {
1, 2, 3, 4, 5};

const size_t NumMyInts = sizeof(MyInts)/sizeof(MyInts[0]);

Bạn thậm chí có thể sử dụng thuật toán STL đối với mảng này, giống như cách bạn sử dụng thuật toán đối với vectơ const ...

const int* myInt = std::find( &MyInts[0], &MyInts[NumMyInts], 3);

Bạn có thể thực hiện theo hai bước:

namespace {
    const T s_actual_array[] = { ... };
    const std::vector<const T> s_blah(s_actual_array,
        s_actual_array + (sizeof(s_actual_array) / sizeof(s_actual_array[0])));
}

Có lẽ không đẹp như bạn có thể thích, nhưng có chức năng.

Làm thế nào về:

int ar[]={1,2,3,4,5,6};
const int TotalItems = sizeof(ar)/sizeof(ar[0]);
std::vector<int> v(ar, ar+TotalItems);

Câu hỏi cũ, nhưng hôm nay tôi lại gặp phải vấn đề tương tự, đây là cách tiếp cận được chấp nhận nhất cho mục đích của tôi:

vector<int> initVector(void)
{
    vector<int> initializer;
    initializer.push_back(10);
    initializer.push_back(13);
    initializer.push_back(3);
    return intializer;
}

int main()
{
    const vector<int> a = initVector();
    return 0;
}

Ví dụ để tránh sao chép quá nhiều:

vector<int> & initVector(void)
{
    static vector<int> initializer;
    if(initializer.empty())
    {
        initializer.push_back(10);
        initializer.push_back(13);
        initializer.push_back(3);
    }
    return intializer;
}

int main()
{
    const vector<int> & a = initVector();
    return 0;
}

Nếu chúng đều giống nhau, bạn chỉ có thể làm

vector<T> vec(num_items, item);

nhưng tôi cho rằng chúng không phải - trong trường hợp đó, cách gọn gàng nhất có lẽ là:

vector<T> vec(num_items);
vec[0] = 15;
vec[1] = 5;
...

C ++ 0x sẽ cho phép bạn sử dụng danh sách khởi tạo chính xác theo cách bạn đang nghĩ, nhưng điều đó không tốt ngay bây giờ, rất tiếc.

Dựa trên phản hồi của Shadow2531, tôi đang sử dụng lớp này để khởi tạo vectơ, mà không thực sự kế thừa từ vectơ std :: như giải pháp của Shadow đã làm

template <typename T>
class vector_init
{
public:
    vector_init(const T& val)
    {
        vec.push_back(val);
    }
    inline vector_init& operator()(T val)
    {
        vec.push_back(val);
        return *this;
    }
    inline std::vector<T> end()
    {
        return vec;
    }
private:
    std::vector<T> vec;
};

Sử dụng:

std::vector<int> testVec = vector_init<int>(1)(2)(3)(4)(5).end();

So với giải pháp của Steve Jessop, nó tạo ra nhiều mã hơn, nhưng nếu việc tạo mảng không quan trọng về hiệu suất, tôi thấy đây là một cách hay để khởi tạo một mảng trong một dòng

Không chắc liệu tôi có hiểu bạn đúng không. Tôi hiểu câu hỏi của bạn như sau: bạn muốn khởi tạo một vectơ với một số lượng lớn các phần tử. Có gì sai với việc sử dụng push_back()trên vector? :-)

Nếu bạn biết số lượng phần tử sẽ được lưu trữ (hoặc chắc chắn rằng nó sẽ lưu trữ ít hơn lũy thừa tiếp theo là 2), bạn có thể làm điều này, nếu bạn có vectơ con trỏ kiểu X (chỉ hoạt động với con trỏ):

std::vector< X* > v;
v.reserve(num_elems);
X* p = v.begin();
for (int count = 0; count < num_elems; count++)
   p[count] = some_source[count];

Hãy cẩn thận khi thêm nhiều hơn sức mạnh tiếp theo của 2 phần tử, ngay cả khi đang sử dụng push_back(). Con trỏ đến v.begin()sau đó sẽ không hợp lệ.