H
Hicham Mouline
hello,
In the main class of the API of a library, we have a function
class M {
public:
void Calculate( CalcStatus* status, double* result, int tag, Operation
operation );
};
this calculates 1 result, returns a status for 1 tag and 1 operation.
We would like to extend this API with more functions to calculate N
results/statues for N tags and 1 operation,
M results/statues for 1 tag for M operations
M*N results/statues for N tags and M operations for each tag.
M and N are runtime variables. M is of the order of 10. N is of the order of
up to 1000
The question is whether to native arrays or std::vector. Performance is
especially relevant
// This API assumes statuses and resultes arrays are allocated by caller
with appropriate sizes
class M {
public:
void Calculate( CalcStatus statuses[], double results[], const int tags[],
size_t N, Operation operation );
void Calculate( CalcStatus statuses[], double results[], int tag, const
Operation operations[], size_t M);
// Have caller interpret statues and results linearily: (m,n) result is
m*M + n index for e.g.
void Calculate( CalcStatus statuses[], double results[], const int tags[],
size_t N, const Operation operations[], size_t M );
};
Also, the question of clarity/elegance/cleanness arises. This API is to be
used by 3rd party users.
of
// size determined from the const input vectors
class M {
public:
void Calculate( vector<CalcStatus>& statuses, vector<double>& results,
const vector<int>& tags, Operation operation );
void Calculate( vector<CalcStatus>& statuses, vector<double>& results, int
tag, const vector<Operation>& operations);
// use boost::multi_array in this last case
void Calculate( vector<CalcStatus>& statuses, vector<double>& results,
const vector<int>& tags, const vector<Operation>& operations);
};
// perhaps template these function with a template argument that is a
template itself (STL containers) to not force the user to provide a vector
Are there any style conventions re such a case?
regards,
In the main class of the API of a library, we have a function
class M {
public:
void Calculate( CalcStatus* status, double* result, int tag, Operation
operation );
};
this calculates 1 result, returns a status for 1 tag and 1 operation.
We would like to extend this API with more functions to calculate N
results/statues for N tags and 1 operation,
M results/statues for 1 tag for M operations
M*N results/statues for N tags and M operations for each tag.
M and N are runtime variables. M is of the order of 10. N is of the order of
up to 1000
The question is whether to native arrays or std::vector. Performance is
especially relevant
// This API assumes statuses and resultes arrays are allocated by caller
with appropriate sizes
class M {
public:
void Calculate( CalcStatus statuses[], double results[], const int tags[],
size_t N, Operation operation );
void Calculate( CalcStatus statuses[], double results[], int tag, const
Operation operations[], size_t M);
// Have caller interpret statues and results linearily: (m,n) result is
m*M + n index for e.g.
void Calculate( CalcStatus statuses[], double results[], const int tags[],
size_t N, const Operation operations[], size_t M );
};
Also, the question of clarity/elegance/cleanness arises. This API is to be
used by 3rd party users.
of
// size determined from the const input vectors
class M {
public:
void Calculate( vector<CalcStatus>& statuses, vector<double>& results,
const vector<int>& tags, Operation operation );
void Calculate( vector<CalcStatus>& statuses, vector<double>& results, int
tag, const vector<Operation>& operations);
// use boost::multi_array in this last case
void Calculate( vector<CalcStatus>& statuses, vector<double>& results,
const vector<int>& tags, const vector<Operation>& operations);
};
// perhaps template these function with a template argument that is a
template itself (STL containers) to not force the user to provide a vector
Are there any style conventions re such a case?
regards,