Question

如果R是我的行号而C是我的列号我初始化一个像这样的指针：

int * a = (int*) malloc(R*C*sizeof(int));

然后要访问第二行中的第二个元素，我输入：

a[1*c + 1]

我想模仿2D arr。

如何制作一个可以将其转换为a[i][j]到此a[i*c + j]的宏？

Answer 1

宏无法读取和转换方括号。但你可以写：

int (*b)[C] = (void *)a;

然后您可以使用与b[i][j]具有相同含义的a[i*C + j]。

Answer 2

如果您不想为您可能使用的每个动态数组创建一个单独的宏，那么您将需要一些更通用的东西。例如：

#include <cmath>
#include <cstdlib>
#include <fstream>
#include <iostream>
#include <string>
#include <vector>

using namespace std;

// data created by Gadget2
const string gadget_data("particles_64cubed.txt");

int main()
{

cout << "GADGET2: Extracting Desired Data From ASCII File." << endl;

// declaring vectors to store the data
int bins = 135000000; // 512^3 particles = 134,217,728 particles
vector<double> x(bins), y(bins), z(bins);


// read the data file
ifstream data_file(gadget_data.c_str());
if (data_file.fail()) 
{
    cerr << "Cannot open " << gadget_data << endl;
    exit(EXIT_FAILURE);
} 
else
    cout << "Reading data file: " << gadget_data << endl;
string line;
int particles = 0;
while (getline(data_file, line)) 
{
    string x_pos = line.substr(0, 11);
    double x_val = atof(x_pos.c_str());    // atof converts string to double
    string y_pos = line.substr(12, 11);
    double y_val = atof(y_pos.c_str());
    string z_pos = line.substr(24, 11);
    double z_val = atof(z_pos.c_str());

    if (particles < bins) 
    {
        x[particles] = x_val;
        y[particles] = y_val;
        z[particles] = z_val;
        ++particles;
    }
}
data_file.close();
cout << "Stored " << particles << " particles in positions_64.dat" << endl;

vector<double> x_values, y_values, z_values;
for (int i = 0; i < particles; i++) 
{
    x_values.push_back(x[i]);
    y_values.push_back(y[i]);
    z_values.push_back(z[i]);
}

// write desired data to file
ofstream new_file("positions_64.dat");
for (int i = 0; i < x_values.size(); i++)
    new_file << x_values[i] << '\t' << y_values[i] << '\t' << z_values[i] << endl;
new_file.close();
cout << "Wrote desired data to file: " << "positions_64.dat" << endl;

}

然后你可以像这样使用它：

#define INDEX_2D(array, i, j, j_sz) array[ (i) * (j_sz) + (j) ]

尽管如此，这看起来很笨拙。如果你不能使用实际的2d数组，为什么不直接使用直接的索引计算，实际上看起来更清楚？

INDEX_2D(my_array, row, col, C) = x;
printf("%d\n", INDEX_2D(my_array, row, col, C));

Answer 3

预处理器不是伪造1D阵列上的2D阵列访问的好工具。另一种方法是创建一个指向1D数组的指针数组，如下所示：

int *a = malloc( R * C * sizeof *a ); // do not cast the result of malloc!
int *b[] = { &a[0], &a[C], &a[2*C], ..., &a[(R-1) * C] };

结果类似于以下内容（假设R == 2和C == 3）：

   +---+                +---+
b: |   | b[0] -----> a: |   | a[0]
   +---+                +---+
   |   | b[1] ---+      |   | a[1]
   +---+         |      +---+
                 |      |   | a[2]
                 |      +---+
                 +----> |   | a[3]
                        +---+
                        |   | a[4]
                        +---+
                        |   | a[5]
                        +---+

这样，您可以使用b[i][j]访问a（b[i][j] == a[i * R + j]）中的元素。

如何使用C中的宏将int指针作为2D数组访问？

3 个答案: