Thread: Memory Order in Classes

It seems to me like you have a solution looking for a way to be implemented.

Using array overlays and pointers to the middle of arrays is pretty hackish even in C.
Sure it solves one aspect of the problem very neatly, but it's making life hard for the rest of it.

In C++, you should be focussing on the problem side and designing interfaces which express the problem in intuitive ways.

Exactly how you implement that inside the class should be entirely invisible to the outside world. That's the whole point, you can then reimplement the class in different ways and all the users are blissfully unaware of what's going on.

Maybe explore the rich goodie bag of stuff which is the STL
http://www.sgi.com/tech/stl/Vector.html

You should use accessors to get the data in the class, thus hideing the difference between accessing the whole array and just the second part.

The C++ elegance comes from the encapsilation that accessors provide.

Or you could just learn object oriented programming. . .

I don't mean to sound snobby. I am actually not as much of an expert as I sometimes make myself out to be.

But learning the principles of OO is probably a good idea because it is used alot in proffestional developement. I suggest you read and follow that book of yours because it really is the latest common practice.

C++ OO can actually lead to some lenthy code compaired to procedural programming. That part is not a garenteed benifit. Indeed for small programs making elaborate classes is usually overkill. But for large programs OO helps keep the parts in seperate managable pieces, amung other things.

Most of the time routines either read data or change data, but not both. Accessors are used to standardize reading data, and mutators are used to standardize changing the data. If you need more advanced operations, you should make them meathods. But you don't want meathods for things not directly related to the class.

So instead of the above line of code you gave, I would suggest this:

Code:

class Data{
    private:
        cons int STORE_SIZE = 20;
        cons int VARS_OFFSET_Q = 10;
        int storage[STORE_SIZE];
    public:
        //Note: these meathods are made inline for a shorter example code.
        //It is probably better to make them not inline.
        const int *getStorage() {return storage}
        const int *getPart(){return storage + VARS_OFFSET_Q}
        void setStorage(int *store) : storage(store) {}
};

The use of this may seem strange at first. Instead of that extra set of parenthesis you were first talking about, you have 5 addinional characters. But the advantage is that it's the same for both part and storage. And should be the same for most other classes.

Originally Posted by Tonto

Code:

class has array of stuff

const something & operator [] (index) const returns stuff[index]
stomething & operator [] (index) returns stuff[index]

const iterator derivativestuffbegin const returns &stuff[beginofdstuff]
const iterator derivativestuffend const returns &stuff[endofdstuff]

iterator derivativestuffbegin returns &stuff[beginofdstuff]
iterator derivativestuffend returns &stuff[endofdstuff]

const iterator integralstuffbegin const returns &stuff[beginistuff];
const iterator integralstuffend const returns &stuff[endistuff];

iterator integralstuffbegin returns &stuff[beginistuff];
iterator integralstuffend returns &stuff[endistuff];

http://www.parashift.com/c++-faq-lit...html#faq-18.12

Yep, this would be even more elegant than what I wrote. But if the only difference between the integralstuff and the derivativestuff is that the dirivative stuff is a smaller list starting later on in the sequence, this might be overkill. Just returning the array or other container with the data should be enough.

> friend double* Q( RAY* ray ) { return ray->vars + VARS_OFFSET_Q ; }
So don't make it a function, make it a variable

Code:

class myclass {
  private:
    double data[20];
  public:
    myclass ( ) {
      Q = &data[10];
    }
  friend double *Q;
};

Then you can just use
Q[5] as being an alias for data[15]

Make Q a public member of the class then?