将NumPy切片循环代码移植至C++的实现求助

Hey there! Let's break down exactly how to translate those four lines of NumPy code into clean, safe C++. First, let's recap what your Python code is doing to make sure we're on the same page:

1. Creates an empty 2D array result with 539 rows and 181 columns
2. For each row i:
   • Copies the 180 elements from orig starting at index i into the first 180 columns of row i in result
   • Calculates the difference between orig[i+180] and orig[i+179] (the last element of the copied slice and the next one) and stores it as the 181st element of row i

Step 1: Set Up the Result Array #

In C++, the safest way to handle dynamic 2D arrays is using std::vector (from the <vector> header). This replaces NumPy's np.empty:

#include <vector>
#include <algorithm> // For std::copy

// Assume orig is a 1D vector of your data type (double, float, etc.)
std::vector<std::vector<double>> result(539, std::vector<double>(181));

Note: Unlike np.empty, this initializes all elements to 0 by default. If you need to avoid initialization (for performance reasons), you can use a more low-level approach with raw pointers, but std::vector is highly recommended for safety and readability.

Step 2: Loop and Populate the Result Array #

Now we'll replicate the Python loop. We'll use std::copy to efficiently copy the slice of orig (this is equivalent to NumPy's array assignment result[i, :180] = orig[i:i+180]):

for (int i = 0; i < 539; ++i) {
    // Copy 180 elements from orig starting at index i to result[i]'s first 180 positions
    std::copy(orig.begin() + i, orig.begin() + i + 180, result[i].begin());
    
    // Calculate the difference and assign to the last column
    result[i][180] = orig[i + 180] - orig[i + 179];
}

Key Notes to Avoid Bugs #

• Ensure orig has enough elements: Your loop runs up to i = 538, which means orig needs to have at least 538 + 181 = 719 elements (since we access orig[i+180]). If orig is too short, you'll get undefined behavior (crashes or garbage values).
• Data types: Replace double with float (or another numeric type) if your original data uses single-precision floats.
• Raw Array Alternative: If you prefer using C-style arrays (not recommended for most cases), here's how that would look:

double result[539][181];
double orig[719]; // Make sure this is properly initialized

for (int i = 0; i < 539; ++i) {
    // Copy the slice manually
    for (int j = 0; j < 180; ++j) {
        result[i][j] = orig[i + j];
    }
    // Calculate the difference
    result[i][180] = orig[i + 180] - orig[i + 179];
}

This manual loop works, but std::copy is more efficient and cleaner for the slice copy.

Hopefully this gets you un-stuck after that long day of porting! Let me know if you run into any issues with data types or array bounds.

内容的提问来源于stack exchange，提问作者Nicholas Kunes