C++Talk.NET

dagecko · Guest

Hi,

First of all, sorry for my bad english, I hope you'll understand
what I'd like to mean.

I don't know if it's an interresting proposal but in some ways
I needed it. I actually simply avoid that 'problem' by simply
using data members.
I know what I propose is somewhat different from what C++ classes
are actually, but I guess that is not a contradiction.

Here is the stuff:

Imagine that scenario:

There's a class which needs to do several things (threw different
functions). Each function uses data members of the class so that
each instance has its own values (this turns out, that's the
way C++ does the things).
Now some functions can use some members but not others and that
could be the case for almost all the member functions of the
class.

Here we can represent that class:

class C: public X // might or not inherit from another class
{
int a;
int b;

// might have other data members

public:

void funcA()
{
// do things with a ONLY
}

void funcB()
{
// do things with b only
}
};

Depending on the needs, C instances might only call to funcA
or funcB but rarely both (and maybe never). Also, using static
data member inside the member functions would not help as
a and/or b are states per instance.
So, with that class, each instance of C have the same size:
they all need to allocate memory for both a and b plus for
all the other members (and inherited members).

It's not a big problem when we use only 2 integers, but
could be much more of a problem if there are many primitive
types or big types (as big classes).

I know there's the solution to truncate that class into 2
classes and by using polymorphism we could achieve good
results. But this is not always possible, almost when the
class C already belongs to a big hierarchy and when that
concerns a single member function (or 2 like here). The
main problem is that funcA or funcB could be called only
under some specific circumstances (mainly depending on the
states of other data members).

So here is what I thought of:

class C: public X // might or not inherit from another class
{
// int a; no need for them anymore here !
// int b;

public:

void funcA()
{
static_instance int a;
// do things with a ONLY
}

void funcB()
{
static_instance int b;
// do things with b only
}
};

Here static_instance would tell that a and b belong to the
instance and the matching member function from which it is
called. Its scope is not to a class (so not like
static does with data members), and neither from the life
of a function call (so not like auto data members of
functions).
It's created only when an instance of C uses funcA or funcB
and its life length is the instance life length.

So we could then produce code like this one:

C c1, c2;

c1.funcA(); // c1::funcA::a holds a new value: x1
c2.funcA(); // c2::funcA::a holds a new value: x2
c1.funcA(); // c1::funcA::a holds a new value: y1
c2.funcA(); // c2::funcA::a holds a new value: y2

This proposal is almost made for low memory consumption and
for security. Here there's no need to allocate memory for
a and b for all instances of C, so C is lighter. But I
acutally do not know where to allocate memory for a and/or b
when there's need for (when funcA and/or funcB is called).
Maybe another specific storage. Fortunately, this might be
known at compilation time, but this is not really sure, a
simple code like this might put the compiler under unknown
behavior:

if (some_thing)
c1.funcA();
else
c1.anotherFunc();

Also, I spoke about security. This might be true almost when
C belongs to a hierarchy, so that ensuring no other functions
will be able to use a and/or b. This might be interresting
for a library for example (a bit like private members).

(PS. I also posted it on comp.std.c++)

[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]

benben · Guest

Calvin · Guest

Dear dagecko,

class C: public X
{
public:
virtual void func() = 0;
};

class CA: public C
{
int a;

void funcA() {...}
public:
virtuall void func() { funcA(); }
};

class CB: public C
{
int b;

void funcB() {...}
public:
virtual void func() { funcB(); }
};

C* ca = new CA;
C* cb = new CB;

ca->func(); // call funcA()
cb->func(); // call funcB()

[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]

Kurt Stege · Guest

dagecko wrote:

dagecko · Guest

This is not what I meant. I don't want to hide funcA and funcB
inside another member function. Also, sometimes, polymorphism
isn't accurate for some motivations. And I told that in some
ways, users might need to call both funcA and funcB, in that
case, your way isn't a solution but with using multiple
inheritence. I have nothing against multiple inheritence, but
that might not help under some circumstances, ie when the
programmer uses a library he didn't wrote, so he can't change it
as he wishes (and specially he might not be able to inherit
from some library classes, mainly if instances are created
regarding a config file or if the library wasn't wrote for allowing
multiple inheritence to be done easily, ie if base classes are not
made virtual).

Well I see I can't tell any good example, and I know the examples
I made could be made differently without the necessity of a new
keywoard. That mainly depends on how the code is created, and how
the code could be created: Sometimes, design does not allow some
things to be done as easily as in a simple short and not in
real situation example.

But I have another motivation that I didn't want to show now
because it might be subject to several controversies and also
because I didn't want to share it now since it doesn't tend
to a 'perfection'.

I called it DisparatContainer, its objectives are to set and
get values in a container regarding their types. I'd have several
uses for such a concept, but I actually can't do it as I wish
because of its current inconveniencies.

So here it is:

class DisparatContainer
{
public:

template <class T>
T* const
Do (T *t = 0)
{
static T *_t = 0;

if (t)
_t = t;

return _t;
}
};

The main interrest of such a class is to allow users to get values
regarding the type they specify. But as this, all instances of this
class will own the same values regarding the types:

int i = 1;
float j = 1.2;

DisparatContainer a, b;

cout << *a.Do (&i) << endl; // returns 1
cout << *a.Do (&j) << endl; // returns 1.2
cout << *a.Do<int>() << endl; // returns 1
cout << *a.Do<float>() << endl; // returns 1.2
cout << a.Do<long>() << endl; // returns null pointer

// static_instance would help having several disparat
// containers owning the same things !!

cout << *b.Do<float>() << endl; // also returns 1.2 !!

Here, a and b hold exactly the same things. This is not a good
thing because a program might need different instances of this
type. The only solution to this is to create as much class of
this kind as needed. But the fallback is that they will be
different types, so requesting other parts of the program that
will need that to be templated.

So here something like that would have help more:

class DisparatContainer
{
public:

template <class T>
T* const
Do (T *t = 0)
{
static_instance T *_t = 0; // note static_instance here

if (t)
_t = t;

return _t;
}
};

Here instances a and b will hold different values. And as far
as I know, there aren't any other way to do that.
I also know that new keywoards are the last thing to add to C++
(as told by B. Stroustrup), but in some ways I need such a
kind of possibility.

Finally, I don't know how far this is interresting, neither how
far it is doable. But it would at least be nice if we could
discuss about it.

Hope that's understandable now.

regards.

[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]

dagecko · Guest

Le Thu, 09 Feb 2006 09:42:38 -0500, Kurt Stege a écrit :

Kurt Stege · Guest

dagecko wrote:

nobody@ebi.ee · Guest

dagecko <dagecko (AT) free (DOT) fr> wrote in
news:pan.2006.02.08.17.45.04.805445 (AT) free (DOT) fr:

[...]

Guest · Posted: Sat Feb 18, 2006 1:06 am Post subject: Re: static_instance

dagecko wrote: