Re: Providing a no-overhead way for a contained class to access its
container?
On Jun 17, 2:03 pm, PeteOlcott <PeteOlc...@gmail.com> wrote:
On Jun 17, 9:45 am, Puppet_Sock <puppet_s...@hotmail.com> wrote:
On Jun 17, 8:30 am, PeteOlcott <PeteOlc...@gmail.com> wrote:
[snips]
What about the case where the contained class must store its data in
its container?
It's not even a little clear what you mean.
Do you mean: The objects in the container stick copies
of themselves into the same container? If so, then you
have a pathological design that should be refactored.
Do you mean: Actual copies of the objects are stored in
the container, as opposed to pointers to the objects?
If that's the issue, and you are concerned about such
things as excess effort involved in swapping copies
instead of pointers, there are many ways of proceeding.
Or do you mean something else?
Socks
Here is what I mean. For this specific use it is about the highest
performance (space and time) possible. A Large number of Contained
elements can be read in and written to disk as a single block read or
block write. Also all of the extra memory allocation overhead that
would normally be associated with the individual Contained elements
has been reduced to making two large allocations.
Ok, I have to say your response had a lot of words in it,
but didn't come near to answering the question. And, after
nearly 30 posts in this thread, we finally illicit some
part of the actual spec. You seem to be talking about
writing stuff to disk, and reading it back, in an efficient
manner, when you have a bunch of objects stored in a
container class of some kind.
#define uint8 unsigned char
#define uint32 unsigned int
ContainedClass {
uint32 Offset;
bool operator<(const ContainedClass& CC);
}
ContainerClass {
uint32 Length; // All ContainedClass elements are the same Lengt=
h
std::vector<uint8> Bytes;
std::vector<ContainedClass> Contained;
uint8& operator[](uint32 N){ return Bytes[N]; };
void sort(){ std::sort(Contained.begin(), Contained.end()) };
} Container;
bool ContainedClass::operator<(const ContainedClass& CC)
{
uint32 Last = this->Offset + Container.Length;
for (int N = this->Offset, M = CC.Offset; N < Last; N++, M++)
if (Container[N] < Container[M])
return true;
else if (Container[N] > Container[M])
return false;
return false; // They must be Equal, thus Not(LessThan)
}
Though your sample code does not seem to be related to the
issue of reading from or writing to disk. Plus, what you
posted sure won't compile.
If what you want to do is an efficient read/write of a large
block of data, there are a variety of approaches. None of
them need the object to know it is contained in a container.
Is that what you are on about? Storing and reading back
a std container of objects?
Socks