Finding the Intersect of 'n' Generic Arrays - c++

Question

EDIT : Added far more detail.
I'm trying to write an algorithm that finds the intersection (points common to all) of n arrays. My program takes these arrays and stores them in a two dimensional array on which the operations take place. For example, here is a sample main method:
int a[] = { 12, 54, 42 };
int b[] = { 54, 3, 42, 7 };
int c[] = { 3, 42, 54, 57, 3 };
IntersectionTableau<int> x(3); // Where 3 is the max number of arrays allowed
// to be stored.
x.addArray(a, 3);
x.addArray(b, 4);
x.addArray(c, 9);
x.run(); // Finds the intersection.
These added arrays will be stored in T** arrays and their sizes in int* sizes. T is a generic type. What is an efficient algorithm that will let me do this on a variable number of arrays of generic types?
Here is what I'm currently attempting to do:
template <class T>
inline
void IntersectionTableau<T>::run() {
T* commonElements = d_arrays[0];
for (int i = 1; i < d_currentNumberOfArrays; ++i) {
commonElements = getIntersection(commonElements, d_arrays[i], d_sizes[i - 1], d_sizes[i]);
}
d_results = commonElements;
}
template <class T>
inline
T* IntersectionTableau<T>::getIntersection(T* first, T* second, int sizeOfFirst, int sizeOfSecond) {
T* commonElements;
if (sizeOfFirst > sizeOfSecond) {
commonElements = new T[sizeOfFirst];
} else {
commonElements = new T[sizeOfSecond];
}
for (int i = 0; i < sizeOfFirst; ++i) {
for (int j = 0; j < sizeOfSecond; ++j) {
if (first[i] == second[i]) {
commonElements[i] = first[i];
}
}
}
return commonElements;
}
The first function takes the first two arrays and sends them to the second function, which returns an array of the intersections between those two arrays. Then, the first function compares the intersection array with the next array in d_arrays and so on. My problem is when I go to print out an element from d_results a garbage value is produced, and I'm unsure why. Could someone tell me what I'm doing wrong, or alternatively, a better way to accomplish this?

Answer 1

There are at least two problems in the code:
if (first[i] == second[i])
This should be if (first[i] == second[j]).
commonElements[i] = first[i];
This is trickier to fix. I think you want to have another variable (neither i nor j); let's call it k:
commonElements[k++] = first[i];
Anyway, since you can use C++, you can use a std::vector instead. It stores its size inside; this will reduce confusion:
template <class T>
std::vector<T> // note: adjusted the return type!
IntersectionTableau<T>::getIntersection(...)
{
std::vector<T> commonElements;
for (int i = 0; i < sizeOfFirst; ++i) {
for (int j = 0; j < sizeOfSecond; ++j) {
if (first[i] == second[j]) {
commonElements.push_back(first[i]);
}
}
}
return commonElements;
}
You can turn first and second into vectors too (though you won't benefit much from it right now).
Here are some points to note:
I changed the return type to vector<T>
The old version, which returns an array, requires additional code to specify the length of its result; this version returns the length inside the vector<T> object
The old version, which returns an array, requires delete[] array somewhere later, to prevent a memory leak
The vector-to-pointer hack &commonElements[0] will not work for an empty vector
If your other code works with an array/pointer, you can use the vector-to-pointer hack &commonElements[0], but outside the function, in order to respect the lifetime rules:
T* commonElements = NULL;
for (int whatever = 0; whatever < 10; ++whatever)
{
std::vector<T> elements = xxx.getIntersection(...); // will work
commonElements = &elements[0]; // can pass this pointer to a function receiving T*
print(commonElements); // will work
}
print(commonElements); // cannot possibly work, will probably segfault
print(elements); // cannot possibly work, and compiler will reject this