CODEWITHSUNDEEP
c++stliterator
user2303321
user2303321

Reputation: 327

Implement Iterators Even When Not Needed? C++

I have a container called "ntuple" that is essentially a C array and length. It's main purpose is to be the argument of multi-dimensional math functions. As of now, it's really fast and utilizes several constructors of the form

ntuple(double x, double y, double z)
{
    size = 3;
    vec = new double[size];
    vec[0] = x;
    vec[1] = y;
    vec[2] = z;
}

And every time I work with a higher dimensional, yet known function, I just add a new constructor. I have on for an array as well:

ntuple(double* invec, long unsigned insizesize)

In order to make my code more compatible with regular c++ code, should I implement an ntuple iterator class? Nothing I've done has needed one and it seems like it will just slow everything down. But the more I read, the more vital it seems to use iterators for the sake of compatibility with standard C++ code.

I worry that when someone tries to work with my code, it won't mesh well with the standard techniques that they expect to use. But the purpose of my ntuple class is just to take arguments into functions.

Should I implement the iterators just as a precaution (if someone else will try to use the STL on it) at the cost of slowing my code?

Thanks.

Upvotes: 1

Views: 121

Answers (2)

Peter K
Peter K

Reputation: 1807

Yes, use vector but (if you really have lots of data in memory) be very careful to manage vector's memory. Then you will really have this 4 byte overhead (wasted for capacity).

  • allways create vector with explicit size, or create empty and use resize()
  • fill vector using indices (as you do vec[0] = ...)
  • never use push_back - it can request (twice) more memory than needed

You can also enforce this rules with inheriting vector (though sometimes this practice is not recommended) like this

class ntuple: public std::vector<double> {
private:
    typedef std::vector<double> super;
    void push_back(double); // do not implement
    // also forbid pop_back()
public:
    ntuble(double a, double b) {
      resize(2);
      (*this)[0] = a;
      (*this)[1] = b;
    }
    ntuple(double* invec, long unsigned size)
      : super(invec, invec + size)
    {
    }
    // all your other convenient constructors here
};

iterators will still be accessible with begin() and end() methods

Upvotes: 0

Yakk - Adam Nevraumont
Yakk - Adam Nevraumont

Reputation: 275976

Implementing iterators for a wrapper around a C array is trivial -- just return pointers to the first, and one-past-the-last, element for begin and end respectively, and adding non-virtual methods to a POD class won't slow down much of anything. Accessing the array via these methods won't be any slower than using array index lookups, and can be faster in some contexts. And if you don't use them, your code won't run slower.

As an advantage, in C++11 if you have a begin and end method, std::begin and std::end will find it, and for( auto x: container ) { /* code */ } will work on your type.

As this seems to be an X/Y problem, I suspect one of your problems is that you shouldn't be using your ntuple class at all. std::vector<double> is already a thin wrapper around a C-style array that is well written. To pass it without the cost of copying it, std::vector<double> const&.

As a pedantic aside, the STL refers to the library from which the template component of std was derived. It differs slightly from the std library in a few ways.

Upvotes: 5

Related Questions