Renaming versus initialisation

Renaming versus initialisation

[Tapio Kelloniemi]

Hi

Assuming the following declarations:

type T is ...;

function F return T is ...;

I'm a bit uncertain about the difference of the following declarations:

V1 : T := F;
V2 : T renames F;

I'd like to see an explanation of the effect of an object renaming
declaration versus variable declaration and initialisation, when the object
being renamed is a return value of a function. Many thanks for it.

-- 
Tapio

Re: Renaming versus initialisation

[Robert A Duff]

Tapio Kelloniemi <invalid@localhost.localdomain.com> writes:

> V1 : T := F;
> V2 : T renames F;
> 
> I'd like to see an explanation of the effect of an object renaming
> declaration versus variable declaration and initialisation, when the object
> being renamed is a return value of a function. Many thanks for it.

They are pretty similar.  Differences: V2 is a constant, but V1 is a
variable.  In Ada 95, V2 works for limited types, but V1 does not.
The rules about limited types are relaxed in Ada 2005.

- Bob

Re: Renaming versus initialisation

[Dmitry A. Kazakov]

On 27 Sep 2005 20:00:56 -0400, Robert A Duff wrote:

> Tapio Kelloniemi <invalid@localhost.localdomain.com> writes:
> 
>> V1 : T := F;
>> V2 : T renames F;
>> 
>> I'd like to see an explanation of the effect of an object renaming
>> declaration versus variable declaration and initialisation, when the object
>> being renamed is a return value of a function. Many thanks for it.
> 
> They are pretty similar.

What about difference in respect to creation of new objects?

-- 
Regards,
Dmitry A. Kazakov
http://www.dmitry-kazakov.de

Re: Renaming versus initialisation

[Tapio Kelloniemi]

"Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> wrote:
>On 27 Sep 2005 20:00:56 -0400, Robert A Duff wrote:
>
>> Tapio Kelloniemi <invalid@localhost.localdomain.com> writes:
>>
>>> V1 : T := F;
>>> V2 : T renames F;
>>>
>>> I'd like to see an explanation of the effect of an object renaming
>>> declaration versus variable declaration and initialisation, when the object
>>> being renamed is a return value of a function. Many thanks for it.
>>
>> They are pretty similar.
>
>What about difference in respect to creation of new objects?

Renaming creates a new object as does initialisation, when not
returning by reference (return value is copied = new object is created).

-- 
Tapio

Re: Renaming versus initialisation

[Dmitry A. Kazakov]

On Wed, 28 Sep 2005 15:12:23 GMT, Tapio Kelloniemi wrote:

> "Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> wrote:
>>On 27 Sep 2005 20:00:56 -0400, Robert A Duff wrote:
>>
>>> Tapio Kelloniemi <invalid@localhost.localdomain.com> writes:
>>>
>>>> V1 : T := F;
>>>> V2 : T renames F;
>>>>
>>>> I'd like to see an explanation of the effect of an object renaming
>>>> declaration versus variable declaration and initialisation, when the object
>>>> being renamed is a return value of a function. Many thanks for it.
>>>
>>> They are pretty similar.
>>
>>What about difference in respect to creation of new objects?
> 
> Renaming creates a new object as does initialisation,

No, it creates a view.

> when not
> returning by reference (return value is copied = new object is created).

Try this with GNAT:

with Ada.Finalization;
package Foo is
   type T is new Ada.Finalization.Controlled with null record;
   procedure Finalize (X : in out T);
   function Create return T;
end Foo;
------------------------------------
with Ada.Text_IO;
package body Foo is
   procedure Finalize (X : in out T) is
   begin
      Ada.Text_IO.Put_Line ("Finalize");
   end Finalize;
   function Create return T is
   begin
      return (Ada.Finalization.Controlled with null record);
   end Create;
end Foo;
---------------------------------
with Foo;  use Foo;
with Ada.Text_IO;
procedure Baz is
begin
   Ada.Text_IO.Put_Line ("Initialization:");
   declare
      X : T := Create;
   begin
      null;
   end;
   Ada.Text_IO.Put_Line ("Renaming:");
   declare
      X : T renames Create;
   begin
      null;
   end;
end Baz;

The output should look like:

Initialization:
Finalize             -- X value created before ":="
Finalize             -- A local object in Foo
Finalize             -- X value assigned by ":="
Renaming:
Finalize             -- A local object in Foo
Finalize             -- X value renamed

A compiler has right to optimize out the local object. I believe, it also
can optimize out initialization/finalization pair of the target in
declaration with initialization, so in the end it could be same, though it
isn't in GNAT.

-- 
Regards,
Dmitry A. Kazakov
http://www.dmitry-kazakov.de

Re: Renaming versus initialisation

[Jeffrey R. Carter]

Dmitry A. Kazakov wrote:

> A compiler has right to optimize out the local object. I believe, it also
> can optimize out initialization/finalization pair of the target in
> declaration with initialization, so in the end it could be same, though it
> isn't in GNAT.

I think this analysis is correct. This is compiler dependent. The only 
language-required difference is that renames creates a constant and 
initialization can create a variable.

-- 
Jeff Carter
"You tiny-brained wipers of other people's bottoms!"
Monty Python & the Holy Grail
18