hello, I'm having a simple problem. Let's say I have a class

class Foo
{
int size; // size var

this(int _size) // size this will set it
{
size = _size; // set size to size
}
}

the problem is that I have to _size for the function var.
To me this seems messy, I could also use sizevar or some other strange name but
I
feel _size is the closest I could get to size.

What I wouldn't mind is a standard way to declare, for member functions at
least,
something that would help tell it apart from the class member variables.

Maybe something like this...

class Foo
{
int size;

this(int @size) // the '@' signifies it as a member function argument
{
size = @size; // this way you can tell member vars from function arguments
}

}

so does anyone else think something like this would be good? is there a better solution already available?

clayasaurus wrote:
> hello, I'm having a simple problem. Let's say I have a class
> 
> class Foo
> {
> int size; // size var
> 
> this(int _size) // size this will set it
> {
> size = _size; // set size to size
> }
> }
> 
> the problem is that I have to _size for the function var. To me this seems messy, I could also use sizevar or some other strange name but
> I feel _size is the closest I could get to size. 

How about just using m_size for member vars. I think it's quite a standard naming convention...


> What I wouldn't mind is a standard way to declare, for member functions at
> least, something that would help tell it apart from the class member variables. 
> 
> Maybe something like this...
> 
> class Foo
> {
> int size; 
> 
> this(int @size) // the '@' signifies it as a member function argument {
> size = @size; // this way you can tell member vars from function arguments
> }
> 
> }
> 
> so does anyone else think something like this would be good? is there a better solution already available? 

If we were to go that way somehow, @ should be used for member vars, not for params. It's how Ruby does it, so some ppl would already be familiar with that thing.

clayasaurus wrote:

> hello, I'm having a simple problem. Let's say I have a class
> 
> class Foo
> {
> int size; // size var
> 
> this(int _size) // size this will set it
> {
> size = _size; // set size to size
> }
> }
> 
> the problem is that I have to _size for the function var. To me this seems messy, I could also use sizevar or some other strange name but
> I feel _size is the closest I could get to size. 
> 
> What I wouldn't mind is a standard way to declare, for member functions at
> least, something that would help tell it apart from the class member variables. 
> 
> Maybe something like this...
> 
> class Foo
> {
> int size; 
> 
> this(int @size) // the '@' signifies it as a member function argument {
> size = @size; // this way you can tell member vars from function arguments
> }
> 
> }
> 
> so does anyone else think something like this would be good? is there a better solution already available? 
> 
> 

All I have to say, and this is with no great offense intended, is yuck.  I'm not sure if this works in D, and I don't have the time to test it, but you could always try:

class Foo
{
	int size; // size var

	this(int size)
	{
		this.size = size;
	}
}
or just forget about it entirely.  Especially in that kind of a function, it doesn't matter what you call it, all people care about is that you have a class Foo that has a constructor that takes an integer size.  You could call it this(int max) for all people'd care.

Heck, you could do:

this(int bazooka) // ctor to set the default size
{

}

if you really wanted.  I don't think it's worthy of adding a new symbol to the lexicon just to distinguish fields from locals.

-Deja

In article <cegd35$13h1$1@digitaldaemon.com>, Deja Augustine says...
>
>clayasaurus wrote:
>
>> hello, I'm having a simple problem. Let's say I have a class
>> 
>> class Foo
>> {
>> int size; // size var
>> 
>> this(int _size) // size this will set it
>> {
>> size = _size; // set size to size
>> }
>> }
>> 
>> the problem is that I have to _size for the function var.
>> To me this seems messy, I could also use sizevar or some other strange name but
>> I
>> feel _size is the closest I could get to size.
>> 
>> What I wouldn't mind is a standard way to declare, for member functions at
>> least,
>> something that would help tell it apart from the class member variables.
>> 
>> Maybe something like this...
>> 
>> class Foo
>> {
>> int size;
>> 
>> this(int @size) // the '@' signifies it as a member function argument
>> {
>> size = @size; // this way you can tell member vars from function arguments
>> }
>> 
>> }
>> 
>> so does anyone else think something like this would be good? is there a better solution already available?
>> 
>> 
>
>All I have to say, and this is with no great offense intended, is yuck.
>  I'm not sure if this works in D, and I don't have the time to test it,
>but you could always try:
>
>class Foo
>{
>	int size; // size var
>
>	this(int size)
>	{
>		this.size = size;
>	}
>}
>or just forget about it entirely.  Especially in that kind of a
>function, it doesn't matter what you call it, all people care about is
>that you have a class Foo that has a constructor that takes an integer
>size.  You could call it this(int max) for all people'd care.
>
>Heck, you could do:
>
>this(int bazooka) // ctor to set the default size
>{
>
>}
>
>if you really wanted.  I don't think it's worthy of adding a new symbol to the lexicon just to distinguish fields from locals.
>
>-Deja

I think I'll just use the this.membervar way then. That seems to work. thx.

clayasaurus wrote:

>>class Foo
>>{
>>	int size; // size var
>>
>>	this(int size)
>>	{
>>		this.size = size;
>>	}
>>}
> 
> I think I'll just use the this.membervar way then. That seems to work. thx. 
> 
> 


K, this seems nice, just don't use the 'size' name or you'll have problems :)

Simple, decorate your member variables.

I use m_ (instance / non-static) and sm_ (class / static).  This is what DTL (and STLSoft) uses.

Other schemes are using a _ postfix, which is ok, but less good.

A bad one is using a _ prefix, since that breeds this bad habit elsewhere, and some languages (including D, in some respects, I think) reserve this for the implementation (i.e. the compiler vendor and/or the standard)

The worst of the lot is to have no decoration, since any reader of your code cannot immediately see what are member variables and what are local and/or module/namespace/global variables (for which s_ or g_ can be used). Furthermore, if you forget the this. in member initialisation, your code will have hidden bugs. Very poor.

(Interestingly - and Yes! he's plugging again - I'm working through the final layout proofs of Imperfect C++ at the moment, and have just covered this in chapter 17 - Syntax. Honesty compels me to recommend you pre-order this gem, due out Sept 9th. <G>)



"clayasaurus" <clayasaurus_member@pathlink.com> wrote in message news:cegc93$139u$1@digitaldaemon.com...
> hello, I'm having a simple problem. Let's say I have a class
>
> class Foo
> {
> int size; // size var
>
> this(int _size) // size this will set it
> {
> size = _size; // set size to size
> }
> }
>
> the problem is that I have to _size for the function var.
> To me this seems messy, I could also use sizevar or some other strange name but
> I
> feel _size is the closest I could get to size.
>
> What I wouldn't mind is a standard way to declare, for member functions at
> least,
> something that would help tell it apart from the class member variables.
>
> Maybe something like this...
>
> class Foo
> {
> int size;
>
> this(int @size) // the '@' signifies it as a member function argument
> {
> size = @size; // this way you can tell member vars from function arguments
> }
>
> }
>
> so does anyone else think something like this would be good? is there a better solution already available?
>
>
>
>
>
>
>

On Sat, 31 Jul 2004 15:01:55 +0000 (UTC), clayasaurus wrote:

> hello, I'm having a simple problem. Let's say I have a class
> 
> class Foo
> {
> int size; // size var
> 
> this(int _size) // size this will set it
> {
> size = _size; // set size to size
> }
> }
> 
> the problem is that I have to _size for the function var.
> To me this seems messy, I could also use sizevar or some other strange name but
> I
> feel _size is the closest I could get to size.
> 
> What I wouldn't mind is a standard way to declare, for member functions at
> least,
> something that would help tell it apart from the class member variables.
> 
> Maybe something like this...
> 
> class Foo
> {
> int size;
> 
> this(int @size) // the '@' signifies it as a member function argument
> {
> size = @size; // this way you can tell member vars from function arguments
> }
> 
> }
> 
> so does anyone else think something like this would be good? is there a better solution already available?

For what its worth, for the last many-years now, I've generally been prefixing my identifer names with a code that indicates scope and static-ness. It doesn't take long to write and makes reading code a lot easier.

 class Foo
 {
   private:
    int cSize; // size var

   public:
    this(int piSize) // size this will set it
    {
      cSize = piSize; // set size to size
    }
 }

"c" -->  "class" variable
"pi" --> "parameter in"
"po" --> "parameter out"
"pu" --> "parameter i/o"
"g"  --> "global" / public
"k"  --> "constant" / "static"
"l"  --> "local" to routine
"m"  --> scoped to module

Well it works for me; YMMV

-- 
Derek
Melbourne, Australia

> How about just using m_size for member vars. I think it's quite a standard naming convention...

fSize would be my vote. f as in field. Field being a proper OO term along with attribute and operation.

The @ doesn't read righ if you've ever done any pascal, because @x in pascal is the same as &x in C.

Matt

me wrote:
> The @ doesn't read righ if you've ever done any pascal, because @x in pascal
> is the same as &x in C.

Doesn't read right to anyone familiar with MOO or ColdC either, where @ is used to unbox lists.  Aka, in ColdC I'd do something like:

	foo = [1, 2, 3, 4, 5];
	.bar(@foo);  // the same as doing: .bar(1, 2, 3, 4, 5)

-Chris S.
-Invironz

clayasaurus wrote:

>hello, I'm having a simple problem. Let's say I have a class
>
>class Foo
>{
>int size; // size var
>
>this(int _size) // size this will set it
>{
>size = _size; // set size to size
>}
>}
>
>the problem is that I have to _size for the function var. To me this seems messy, I could also use sizevar or some other strange name but
>I feel _size is the closest I could get to size. 
>
>What I wouldn't mind is a standard way to declare, for member functions at
>least, something that would help tell it apart from the class member variables. 
>
>Maybe something like this...
>
>class Foo
>{
>int size; 
>
>this(int @size) // the '@' signifies it as a member function argument {
>size = @size; // this way you can tell member vars from function arguments
>}
>
>}
>
>so does anyone else think something like this would be good? is there a better solution already available? 
>  
>

I just use lower case (first letter) for parameters and upper for members.


-- 
-Anderson: http://badmama.com.au/~anderson/