Trust finds the maximum value in the array

Make a little progress every day .

rust The procedure for finding the maximum value of elements in the array is as follows ：

fn main() {
    
   let vec = vec![1,2,56,13,68];
   let largest1 = largest1(&vec);
   let largest2 = largest2(&vec);
   println!("largest1 is:{}", largest1);
   println!("largest2 is:{}", largest2);
}

fn largest1(list:&[i32])->i32{
    
   //  Why is the type obtained by subscript i32, And by for The element type obtained by the loop is &i32
   let mut largest = list[0]; //  amount to  let mut largest = (*list.index(0));
   for &item in list {
    
      if largest < item {
    
         largest = item;
      }
   }
   largest
}

fn largest2(list:&[i32])->i32{
    
   let mut largest = list[0];
   for item in list {
    
      if largest < *item {
    
         largest = *item;
      }
   }
   largest
}

We go through vec! Macro call
let vec = vec![1,2,56,13,68];
An array is defined vec,vec The type is Vec<i32>.
By defining largest1 and largest2 Function to find the largest in the array i32 Type values , And back to （rust The value of the last expression in the function is the return value , Note that it is not a statement , That is, there is no semicolon end . It can also be used. return Display the specified return value , This and scala Its grammar is a bit like ）. The functions of the two functions are the same , Just to learn two kinds of quotation and dereference for Usage of loop .

Two largest The input parameter types of functions are &[i32], It means that we just reference the array , Don't take ownership of it .
Let's have a look at it first Clion（ Other development tools such as VSCode It should be the same ） The type information of the variable inferred from is as follows ：

There are two questions to consider ：
1. Why? list yes &[i32] type , and list[0] What we get is i32 type , No &i32 type ?
2. Why? for The elements of the loop can be used &item, It can also be used. item, What's the difference ？

answer ：
1.rust Said on the official website container[index] is actually syntactic sugar for *container.index(index), That is, for container types , Access the elements of the container by subscript , In fact, that is * Containers .index( Subscript serial number ) The grammar sugar of . and Vec Yes, it is container, It has achieved Index trait：

let mut largest = list[0]; amount to let mut largest = (*list.index(0));
list.index(0) The return is &i32 type , It becomes i32 type （ similar C Add an asterisk before the pointer variable in the language to get the variable pointed by the pointer ）.
2.rust Medium for Circulation is actually a grammatical sugar （java China, too , In fact, elements are accessed through iterators ）, It is said on the official website ：
for-in-loops, or to be more precise, iterator loops, are a simple syntactic sugar over a common practice within Rust, which is to loop over anything that implements IntoIterator until the iterator returned by .into_iter() returns None (or the loop body uses break).
about &[i32] Type of list,for The elements in the loop are &i32, So no matter for After the cycle is &item still item, They are taken as a whole , The type is &i32 type , That is, if &item yes &i32, that item Namely i32 type , visit list When using elements in item That's all right. ; If for There is only item, that item Namely &i32 type , Want to visit for The element value in the loop must be dereferenced , That is, through *item Way to obtain list The value of the element in .

---

Reference material ：
1.https://stackoverflow.com/questions/71981790/why-does-indexing-a-vec-return-a-value-instead-of-a-reference-as-promised-by-the
2.https://doc.rust-lang.org/std/ops/trait.Index.html
3.https://doc.rust-lang.org/std/keyword.for.html