Thread: How can I prevent the duplication of stdlib.h in main.cpp?

* moved to C++ programming forum *

Originally Posted by Shafiul

How can I prevent the duplication of stdlib.h in main.cpp?

Duplicate inclusions of standard headers are perfectly fine. It's why you write your own header inclusion guards, after all: so it's perfectly fine should one of your own headers end up included more than once in a translation unit.

EDIT:
Ugh, and you're still not paying attention to C++ best practices. Here's one by Stroustrup and Sutter: R.10: Avoid malloc() and free(). Stroustrup is the designer and original implementor of C++; Sutter has been a prominent member of the C++ standards committee for years.

Here's an (uncompiled, untested) example that's closer to how we would do it in modern C++:

Code:

#ifndef ALLOCATEVECTOR_H
#define ALLOCATEVECTOR_H
// AllocateVector.h

#include <vector>

template<typename T>
std::vector<T> createData1D(std::size_t nRow) {
    return std::vector<T>(nRow);
}

#endif


#ifndef ALLOCATEMATRIX_H
#define ALLOCATEMATRIX_H
// AllocateMatrix.h

#include <vector>

template<typename T>
std::vector<std::vector<T>> createData2D(std::size_t nRow, std::size_t nColumn) {
    return std::vector<std::vector<T>>(nRow, std::vector<T>(nColumn));
}

template<typename T>
class Data2D {
public:
    Data2D(std::size_t nRow, std::size_t nColumn) : nRow(nRow), nColumn(nColumn), data(nRow * nColumn) {}

    T& operator()(std::size_t row, std::size_t column) {
        return data[row * nColumn + column];
    }

    const T& operator()(std::size_t row, std::size_t column) const {
        return data[row * nColumn + column];
    }
private:
    std::size_t nRow;
    std::size_t nColumn
    std::vector<T> data;
};

#endif


//main.cpp
#include <iostream>
#include "AllocateVector.h"
#include "AllocateMatrix.h"

int main()
{
    auto data1D = createData1D<int>(100);
    std::cout << data1D[0] << std::endl;

    auto data2Dnested = createData2D<int>(100, 200);
    std::cout << data2Dnested[10][20] << std::endl;

    auto data2D = Data2D<int>(100, 200);
    std::cout << data2D(10, 20) << std::endl;

    return 0;
}

Want to prevent a duplication of a heade - C++ Forum

See why
How To Ask Questions The Smart Way

Originally Posted by Shafiul

How do you define ex-tern template function inside of AllocateVector.h for createData1D() to avoid the recompilation of the same function. Because AllocateVector.h can be included into different different source (.cpp)

You could use an extern template, but I wouldn't bother: these function templates are good candidates for inlining.

Originally Posted by Shafiul

Moreover the data type of the vector<T> createData1D() can be change at different different run. For example it can be createData1D<int>(100). It also can be createData1D<double>(100). If you have any idea please share.

You need to go into greater detail as to what you have in mind. It could be that you want to use a variant type instead (e.g., the new std::variant), or maybe not.

Your code has an error, although it doesn't show up in your example since you are creating a square matrix.

Code:

    // In allocateData2DbyMalloc, this
    for (unsigned int i = 0; i < nColumn; ++i) {
    // should be this
    for (unsigned int i = 0; i < nRow; ++i) {

You can speed it up a lot by mallocing the data block as one chunk, then setting the pointers, like this:

Code:

    // allocate row pointers
    data2D = malloc(nRow * sizeof *data2D);
    // allocate entire data block
    data2D[0] = malloc(nRow * nColumn * sizeof **data2D);
    // point row pointers into data block
    for (unsigned i = 1; i < nRow; ++i)
        data2D[i] = data2D[i - 1] + nColumn;

Originally Posted by Shafiul

in such a case, imagine, the content of the AllocateVector.h will be compiled in each .cpp file. I am just a bit worry that it can increase the compilation time.

This is a rare case of hearing someone indulge in premature optimisation for compile time, even more strangely when the compiler might be able to optimise for runtime. I'd say that this should be treated like the usual for non-trivial optimisation: measure first, then optimise, i.e., try compiling your actual code, and if it turns out to take so long that it becomes a pain point, look into extern templates or specialising for your common types.

Originally Posted by Shafiul

I performed a simple test to compare the performance speed on malloc() and vector<>. I would like to share with you. The taste case was on a 2D array with 1000x1000 with the number of iteration of 1000. The malloc array took 91.3s where as the vector array took 131.5 s. I wonder about the correct implementation on code for the comparison on the those two array.

You're right to suspect that the two code snippets aren't doing the same thing: the vector does default initialisation, whereas malloc doesn't. One way to avoid this is to reserve the final capacity, then push_back or emplace_back the new elements in the loop.

More importantly though, did you compile with optimisations turned on, range checking turned off, in some kind of release mode (e.g., NDEBUG defined)?

Originally Posted by Shafiul

In the real time simulation of heat transfer, the number of iteration can be around 10000000 for a 2D (1000x1000) matrix.

Will you be spending all those iterations doing nothing but providing initial values? Seems pretty unlikely to me.

Furthermore, john.c is right to say that if you're concerned about efficiency, you wouldn't be allocating in a loop like that when you want a rectangular 2D array for which you already know the dimensions. You're effectively treating it like a jagged 2D array, which is why I demonstrated the equivalent with a vector of vectors... but each vector in a vector of vectors stores its own size (and capacity), which is essential for a jagged 2D array, but redundant for a rectangular 2D array. If you look at my code in post #3 again, you'll see the Data2D class that does a single allocation, then computes the row offsets to compute the index for each element denoted by row and column. You can precompute these row offsets instead by sacrificing a bit more space for pointers to the start of each row, which is what john.c's example does (though with malloc).

> The taste case was on a 2D array with 1000x1000 with the number of iteration of 1000.
> The malloc array took 91.3s where as the vector array took 131.5 s
Right, and having allocated a 1000x1000 array, did you time how long it would take to fill the each with 1000000 values of meaningful data, and do some calculations.

You allocate these things to do some work, and that allocation time is going to be completely INSIGNIFICANT compared to the overall time it takes to do the work.
You're worrying about 40mS between the two, when you've no idea about the minutes or hours it's going to take to get through all that data.

Show us your actual problem, not your attempts to micro-optimise one facet of it.
The XY Problem