矩阵列转std::vector：迭代器及批量转换优化方法问询

Great question! When you need to convert an entire matrix into individual std::vector<T> objects, there are several cleaner and more performant approaches than calling your ExtractMatrixColAsVector function repeatedly. Let's walk through the best options:

1. Optimized Loop with Preallocation #

The most straightforward (and often fastest) method is to iterate over each column directly, using Rcpp's built-in column access and preallocating space for your result to avoid unnecessary memory reallocations.

#include <Rcpp.h>
#include <vector>

template <typename T>
std::vector<std::vector<T>> MatrixToVectorList(Rcpp::NumericMatrix x) {
    std::vector<std::vector<T>> result;
    // Preallocate space for all columns to boost performance
    result.reserve(x.ncol());
    
    for (int col = 0; col < x.ncol(); ++col) {
        // Use x.column(col) for direct, readable column access
        // emplace_back constructs the vector in-place, avoiding copies
        result.emplace_back(Rcpp::as<std::vector<T>>(x.column(col)));
    }
    return result;
}

• Why this works better: By handling all columns in one loop, you eliminate repeated calls to your extraction function. reserve() ensures the outer vector has enough space upfront, and emplace_back() avoids copying temporary vectors.

2. Functional Style with std::transform #

If you prefer a more declarative, function-style approach, you can use std::transform alongside Rcpp's Range to iterate over column indices and convert each column automatically.

#include <Rcpp.h>
#include <vector>
#include <algorithm>

template <typename T>
std::vector<std::vector<T>> MatrixToVectorListFunctional(Rcpp::NumericMatrix x) {
    std::vector<std::vector<T>> result(x.ncol());
    
    // Use Rcpp::Range to generate column indices
    std::transform(
        Rcpp::Range(0, x.ncol() - 1).begin(),
        Rcpp::Range(0, x.ncol() - 1).end(),
        result.begin(),
        [&x](int col) { return Rcpp::as<std::vector<T>>(x.column(col)); }
    );
    return result;
}

• Why this is nice: It's concise and reads like "transform every column index into a vector of its column values". The lambda function keeps the column conversion logic inline.

3. Performance Boost: Direct Iterator Construction #

If you're working with double (the native type of NumericMatrix), you can skip the Rcpp::as<>() call entirely by constructing the std::vector<double> directly from the column's iterators. This cuts out intermediate steps and is the fastest option.

#include <Rcpp.h>
#include <vector>

std::vector<std::vector<double>> MatrixToDoubleVectorList(Rcpp::NumericMatrix x) {
    std::vector<std::vector<double>> result;
    result.reserve(x.ncol());
    
    for (int col = 0; col < x.ncol(); ++col) {
        auto col_view = x.column(col);
        // Construct vector directly from column iterators
        result.emplace_back(col_view.begin(), col_view.end());
    }
    return result;
}

• Why this is faster: x.column(col) returns a view of the column data, so using its begin() and end() iterators constructs the std::vector without copying the data into an intermediate NumericVector first.

Quick Notes on Your Original Code #

Just a small tweak for your single-column extraction: instead of x(_, as<int>(column)), you can use x.column(as<int>(column)) for more readable access. Also, if column is already an integer type (like Rcpp::IntegerVector), you can skip the as<int>() cast entirely.

内容的提问来源于stack exchange，提问作者Harvey Ellis