"ref const" parameters in functions

[L-MAN]

On Saturday, 31 March 2012 at 21:42:05 UTC, Jonathan M Davis 
wrote:
> On Saturday, March 31, 2012 23:25:51 L-MAN wrote:
>> Hello everybody!
>> 
>> I'm trying to use some function FN like this:
>> 
>> struct X
>> {
>>   protected double _x;  // double type for example
>>   public @property double X() const { return _x; }
>> 
>>   // ctor
>>   public this(double x) { _x = x; } // double type for example
>> 
>>   void FN(ref const(double) in_x) // double type for example
>>   {
>>     // ... do some operations with _x
>>   }
>> 
>> }
>> 
>> main(..)
>> {
>>   ....
>>   X x = X(20);
>> 
>>   x.FN(30); // getting an error
>> }
>> 
>> 
>>   why x.FN(20) gets me an error?
>>   the construction "ref const(double)" or "ref 
>> immutable(double)"
>> must be an rvalue by default I think, but in FN parameter the
>> compiler expects an lvalue...
>>   this strategy is the way to some unnecessary copy operations,
>> when value 20 (or some big struct instead of it) will copy to 
>> the
>> stack..
>> 
>> How can I resolve this problem?
>
> Unlike C++, const ref _must_ be an lvalue just like ref. If you 
> use auto ref
> instead of const ref, the compiler is supposed to choose 
> between ref and non-
> ref based on which it thinks would be more efficient, but it 
> currently only
> works with templated types.
>
> You can duplicate the function and have a version whose 
> parameter is const ref
> and one which is not, but be careful if you try and make the 
> non-const ref
> version call the const ref version (to avoid duplicating the 
> function's body)
> and make sure that you don't get infinite recursion. It usually 
> works, but I've
> run into cases before where I ended up with infinite recursion, 
> so make sure
> that you have unit tests which check.
>
> Regardless, if you're dealing with a primitive type like 
> double, don't bother
> with const ref. It's not going to be more efficient. It's with 
> large structs
> that you can see a difference.
>
> - Jonathan M Davis

Thank you for reply, but how can I exclude some copy operations?
Look at this sample:

struct ABC // simple class
{
	private double _d=0;
	@property
	{
		double D() const { return _d; }
		double D(double val) { return _d=val; }
	}
	
	this(double d)
	{
		_d = d;
		writeln(" *** ctor ABC, d = ", _d);
	}
	
	ABC opAdd(ABC abc)
	{
		//ABC temp = ABC(this._d+abc._d);
		//return temp;
		return ABC(this._d+abc._d);
	}

	ABC opMul(ABC d)
	{
		//ABC temp = ABC(this._d*d);
		//return temp;
		return ABC(this._d*d);
	}
		
	ref ABC opAssign(ABC abc)
	{
		this._d = abc.D;
		return this;
	}
	
	~this()
	{
		writeln(" *** dtor ABC, d = ", _d);
	}
}


struct F {

	private ABC _abc;
	
	@property double D() const { return _abc.D; }
	
	public this(ABC abc)
	{
		_abc = abc;
		
		//abc.D=90;
		//pnt.X = 30;
	}
}


void main(string[] args)
{
   ABC abc1 = ABC(10);
   ABC abc2 = ABC(20);
   F f = F(abc1+abc2*20.0);
   writeln(f.D);
  .......
}

Operation abc1+abc2*20.0 consists of   copy of ABC operations: