C ++ 20 std::span

C ++ 20을 사용할 수 있다면 std::span, 사용자에게 연속 된 요소 시퀀스를 보여주는 포인터-길이 쌍을 사용할 수 있습니다 . 그것은 일종의이며 std::string_view, 모두 상태 std::span및 std::string_view비 소유 전망이며, std::string_view읽기 전용이다.

문서에서 :

클래스 템플릿 범위는 위치 0에서 시퀀스의 첫 번째 요소가있는 연속 된 객체 시퀀스를 참조 할 수있는 객체를 설명합니다. 스팬은 정적 범위를 가질 수 있으며,이 경우 시퀀스의 요소 수는 유형으로 알려지고 인코딩됩니다.

따라서 다음과 같이 작동합니다.

#include <span>
#include <iostream>
#include <algorithm>

int main() {
    int data[] = { 5, 3, 2, 1, 4 };
    std::span<int> s{data, 5};

    std::sort(s.begin(), s.end());

    for (auto const i : s) {
        std::cout << i << "\n";
    }

    return 0;
}

실시간 확인

때문에 std::span기본적으로 포인터 – 길이 쌍, 당신은 너무 다음과 같은 방식으로 사용할 수 있습니다 :

size_t size = 0;
int *data = get_data_from_library(size);
std::span<int> s{data, size};

참고 : 모든 컴파일러가 지원하지는 않습니다 std::span. 여기에서 컴파일러 지원을 확인 하십시오 .

최신 정보

C ++ 20을 사용할 수 없으면 gsl::span기본적으로 C ++ 표준의 기본 버전 인을 사용할 수 있습니다 std::span.

C ++ 11 솔루션

C ++ 11 표준으로 제한되어 있다면 자신 만의 간단한 span클래스를 구현해 볼 수 있습니다 .

template<typename T>
class span {
   T* ptr_;
   std::size_t len_;

public:
    span(T* ptr, std::size_t len) noexcept
        : ptr_{ptr}, len_{len}
    {}

    T& operator[](int i) noexcept {
        return *ptr_[i];
    }

    T const& operator[](int i) const noexcept {
        return *ptr_[i];
    }

    std::size_t size() const noexcept {
        return len_;
    }

    T* begin() noexcept {
        return ptr_;
    }

    T* end() noexcept {
        return ptr_ + len_;
    }
};

C ++ 11 버전 라이브 확인

답변

#include <iostream>
#include <algorithm>

int *get_data_from_library(int &size) {
    static int data[] = {5,3,2,1,4};

    size = 5;

    return data;
}


int main()
{
    int size;
    int *data = get_data_from_library(size);

    std::sort(data, data + size);

    for (int i = 0; i < size; i++)
    {
        std::cout << data[i] << "\n";
    }
}

#include <iostream>
#include <algorithm>

int main()
{
    int data[] = {5,3,2,1,4};         // raw data from library

    std::sort(std::begin(data), std::end(data));    // sort raw data in place

    for (int i = 0; i < 5; i++)
    {
        std::cout << data[i] << "\n";   // display sorted raw data 
    }
}

    int data[] = {5,3,2,1,4};
    std::sort(std::begin(data), std::end(data));
    for (auto i : data) {
        std::cout << i << std::endl;
    }

    size_t size = 0;
    int * data = get_data_from_library(size);
    auto b = data;
    auto e = b + size;
    std::sort(b, e);
    for (auto it = b; it != e; ++it) {
        cout << *it << endl;
    }

    std::vector<int> v;
    v.resize(256); // allocate a buffer for 256 integers
    size_t size = get_data_from_library(v.data(), v.size());
    // shrink down to actual data. Note that no memory realocations or copy is done here.
    v.resize(size);
    std::sort(v.begin(), v.end());
    for (auto i : v) {
        cout << i << endl;
    }

std::sort(data, data + size);

template<class T>
struct span {
    T* first;
    size_t length;
    span(T* first_, size_t length_) : first(first_), length(length_) {};
    using value_type = std::remove_cv_t<T>;//primarily needed if used with templates
    bool empty() const { return length == 0; }
    auto begin() const { return first; }
    auto end() const { return first + length; }
};

static_assert(_MSVC_LANG <= 201703L, "remember to switch to std::span");