auto storage class - infer or RAII?

[Sean Kelly]

Kristian Kilpi wrote:
> On Sun, 12 Nov 2006 12:24:35 +0200, Walter Bright 
> <newshound at digitalmars.com> wrote:
>> Sean Kelly wrote:
>>> Walter Bright wrote:
>>>> The auto storage class currently is a little fuzzy in meaning, it 
>>>> can mean "infer the type" and/or "destruct at end of scope".
>>>  As Don explained to me, 'auto' is a storage class in D and in C 
>>> along with 'const' and 'static', so type inference doesn't occur 
>>> because 'auto' is present so much as because a type is omitted.  The 
>>> presence of 'auto' merely serves to indicate that the statement is a 
>>> declaration (since 'auto' is the default storage class and therefore 
>>> otherwise optional).  Type inference occurs with the other storage 
>>> classes as well.  I think this is an important distinction because it 
>>> seems to be a common misconception that 'auto' means 'infer the type 
>>> of this expression' and that a specific label is necessary for this 
>>> feature.
>>
>> True. Consider that type inference works in these cases:
>>
>>     static a = 3;    // a is an int
>>     const b = '3';    // b is a char
>>
>> So auto doesn't actually ever mean "infer the type", it's just needed 
>> because one of the other storage class keywords isn't there.
> 
> So according to this logic, auto should always mean RAII?
> E.g.
> 
>   auto c = new Class;  //RAII

Storage class specifiers are really only intended to indicate how the 
labeled variable (in this case a class reference/pointer) is stored. 
'const' places the variable in a special read-only area, 'static' places 
the variable in static memory, and 'auto' places the variable on the 
stack.  For RAII to apply, the behavior of class references would 
probably need to change so the referenced value is destroyed when the 
reference goes out of scope, and this would effectively eliminate any 
means of returning objects from functions since D objects cannot be 
passed by value.

> If not, then one could argue that
> 
>   static a = 3;
> 
> declares non-static variable, i.e. the static keyword is used for type 
> inference only (whenever the type is omited).

Not at all.  This declares a type-inferred static variable.  The type 
inference occurs because a type is omitted, but the storage class 
specifier still applies.  The same goes for 'const'.


Sean