auto deref or auto ref ?

trait Double {
    fn double(self) -> usize;
}

impl<‘a> Double for &‘a String {
    fn double(self) -> usize { self.len()}
}

impl<‘a, ‘b, ‘c> Double for &‘a &‘b &‘c String {
    fn double(self) -> usize { self.len() * 2 }
}

pub fn main() {
    let x = "hello".to_string(); println!("x:String     => {}", x.double());
    let x = &x;                  println!("x:&String    => {}", x.double());
    let x = &x;                  println!("x:&&String   => {}", x.double());
    let x = &x;                  println!("x:&&&String  => {}", x.double());
    let x = &x;                  println!("x:&&&&String => {}", x.double());
}

OUTPUT:

x:String     => 5
x:&String    => 5
x:&&String   => 10
x:&&&String  => 10
x:&&&&String => 10

how the compiler decide the ord of auto-deref or auto-ref?

if we remove &&&String version of impl:

trait Double {
    fn double(self) -> usize;
}

impl<‘a> Double for &‘a String {
    fn double(self) -> usize { self.len()}
}

pub fn main() {
    let x = "hello".to_string(); println!("x:String     => {}", x.double());
    let x = &x;                  println!("x:&String    => {}", x.double());
    let x = &x;                  println!("x:&&String   => {}", x.double());
    let x = &x;                  println!("x:&&&String  => {}", x.double());
    let x = &x;                  println!("x:&&&&String => {}", x.double());
}

OUTPUT:

x:String     => 5
x:&String    => 5
x:&&String   => 5
x:&&&String  => 5
x:&&&&String => 5

if we remove the &String version of impl:

trait Double {
    fn double(self) -> usize;
}

impl<‘a, ‘b, ‘c> Double for &‘a &‘b &‘c String {
    fn double(self) -> usize { self.len() * 2 }
}

pub fn main() {
    let x = "hello".to_string(); println!("x:String     => {}", x.double());  // error
    let x = &x;                  println!("x:&String    => {}", x.double());  // error
    let x = &x;                  println!("x:&&String   => {}", x.double());
    let x = &x;                  println!("x:&&&String  => {}", x.double());
    let x = &x;                  println!("x:&&&&String => {}", x.double());
}

总结:在做x的方法搜索时,最多只会做一次自动引用,然后就一直做自动解引用。当为一个变量x找搜索方法f时,具体算法如下:

1、当前x上是否有方法f,有调用之;

2、没有,则在x上自动引用一次变成&x,&x上如果有方法f,则调用之;

3、没有,则尝试*x,一直重复3步,直到找到或失败。

时间: 2024-11-10 13:45:48

auto deref or auto ref ?的相关文章

c++中的auto、const auto&amp;

先介绍一下auto.const: 在块作用域.命名作用域.循环初始化语句等等  中声明变量时,关键词auto用作类型指定符. const:修饰符 接下来我们细细分析一下: (1)auto auto即 for(auto x:range)  这样会拷贝一份range元素,而不会改变range中元素: 但是!(重点)  使用for(auto x:vector<bool>)时得到一个proxy class,操作时会改变vector<bool>本身元素.应用:for(bool x:vecto

Auto Layout Guide----(二)-----Auto Layout Without Constraints

Auto Layout Without Constraints 没有约束的自动布局 Stack views provide an easy way to leverage the power of Auto Layout without introducing the complexity of constraints. A single stack view defines a row or column of user interface elements. The stack view a

《Effective Modern C++》翻译--条款2: 理解auto自动类型推导

条款2: 理解auto自动类型推导 如果你已经读过条款1关于模板类型推导的内容,那么你几乎已经知道了关于auto类型推导的全部.至于为什么auto类型推导就是模板类型推导只有一个地方感到好奇.那是什么呢?即模板类型推导包括了模板.函数和参数,而auto类型推断不用与这些打交道. 这当然是真的,但是没关系.模板类型推导和auto自动类型推导是直接匹配的.从字面上看,就是从一个算法转换到另一个算法而已. 在条款1中,阐述模板类型推导采用的是常规的函数模板: template<typename T>

《Effective Modern C++》翻译--条款2: 理解auto自己主动类型推导

条款2: 理解auto自己主动类型推导 假设你已经读过条款1关于模板类型推导的内容,那么你差点儿已经知道了关于auto类型推导的所有. 至于为什么auto类型推导就是模板类型推导仅仅有一个地方感到好奇.那是什么呢?即模板类型推导包含了模板.函数和參数,而auto类型判断不用与这些打交道. 这当然是真的.可是没关系. 模板类型推导和auto自己主动类型推导是直接匹配的. 从字面上看,就是从一个算法转换到还有一个算法而已. 在条款1中.阐述模板类型推导採用的是常规的函数模板: template<ty

c++11中新型for循环,auto, 类成员的初始化及左右值引用

#include <typeinfo> #include <iostream> #include <string> #include <vector> #include <iterator> static void autoValue(); static void autoPointer(); static void newVersionFor(); static void newVersionConstruct(); static void d

iOS开发之Auto Layout入门

随着iPhone6与iOS8的临近,适配的问题讲更加复杂,最近学习了一下Auto Layout的使用,与大家分享.  什么是Auto Layout? Auto Layout是iOS6发布后引入的一个全新的布局特性,其目的是弥补以往Autoresizing在布局方面的不足之处,以及未来面对更多尺寸适配时界面布局可以更好的适应. 为什么要用Auto Layout? Autolayout能解决不同屏幕(iPhone4,iPhone5,iPad...)之间的适配问题. 在iPhone4时代开发者只需要适

c++11 新特性之 auto关键字

C++11是对目前C++语言的扩展和修正.C++11包括大量的新特性:包括lambda表达式,类型推导关键字auto.decltype,和模板的大量改进. g++编译c++11命令加上 -std=c++11 C++11中引入auto第一种作用是为了自动类型推导 auto的自动类型推导,用于从初始化表达式中推断出变量的数据类型.通过auto的自动类型推导,可以简化我们的编程工作 auto实际上实在编译时对变量进行了类型推导,所以不会对程序的运行效率造成不良影响另外,似乎auto并不会影响编译速度,

auto和decltype的用法总结

一, auto 1, auto的作用 一般来说, 在把一个表达式或者函数的返回值赋给一个对象的时候, 我们必须要知道这个表达式的返回类型, 但是有的时候我们很难或者无法知道这个表达式或者函数的返回类型. 这个时候, 我们就可以使用auto关键字来让编译器帮助我们分析表达式或者函数所属的类型. 比如: auto item = val1 + val2; auto red = LayerColor::create(Color4B(255, 100, 100, 255), 200, 100); 如果va

《Linux内核Makefile分析》之 auto.conf, auto.conf.cmd, autoconf.h【转】

转自:http://blog.sina.com.cn/s/blog_87c063060101l25y.html 转载:http://blog.csdn.net/lcw_202/article/details/6661364 在编译构建性目标时(如 make vmlinux),顶层 Makefile 的 $(dot-config) 变量值为 1 . 在顶层 Makefile 的 497-504 行看到: ? 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18