【rust】part-7 self,crate,super、use,as

0.env

ubuntu1804

1. 参数简述

1.self

当前位置，如：

fn get(&self)->u32{
	self.id //指向当前对象的id字段
}

2.crate

绝对路径，如：

mod class{
	mod func{
		fn show(){} //通过绝对路径被调用的函数
	}
}
mod run{
	mod func{
		crate::class::func::show(); //通过绝对路径调用函数
	}
}

3.super

相对路径，如：

mod class{
	mod func{
		fn show(){} //通过相对路径被调用的函数
	}
	mod func_2{
		fn run(){
			super::func::show();// 调用../class/func/show()
		}
	}
}

2.多源码文件

1.工程结构：两个源码文件
2.文件源码及注释

1.工程结构

src
 |----main.rs
 L----func.rs

2.文件源码及注释

/// 1.func.rs
pub fn show_1(i:u32){  // 定义一个pub函数
    println!("show_1 : {}" ,i );
}

/// 2.main.rs
mod func;  // 引入整个mod
fn main() {
    func::show_1(1000);  //通过包的路径调用
}
///

3.use , as

使用如下代码用于举例说明

mod class_a{
    // for use
    pub fn show_a(){
        println!("class_a::show_a()");
    }
    // for use + as
    pub mod show_info{
        pub fn show_a(){
            println!("class_a::show_info::show_a()");
        }
    }
    // for pub + use
    pub mod show{
        pub mod sh{
            pub fn ow(){
                println!("class_a::show::sh::ow()");
            }
        }
    }
    pub use show::sh::ow;
}

1.use

使用use命令来简化书写，避免每次调用都使用完整路径，也可以区分不同mod中的同名函数等，类似C++命名空间等。

use crate::class_a::show_a; //简化路径
fn main{
	show_a();//直接调用，不必指明具体路径
}

2.as

别名，简化。例如区分同名不同包的函数。

/// 为相同代码起个别名 避免简化使用时出现问题
use crate::class_a::show_a;
use crate::class_a::show_info::show_a as show_b;
    show_a();
    show_b();

3.pub + use

在mod内使用。
将某个mod的多级后的函数提到mod::func处使用，避免单独使用use时指明多级目录。

mod class_a{
    // for pub + use
    pub mod show{
        pub mod sh{
            pub fn ow(){
                println!("class_a::show::sh::ow()");
            }
        }
    }
    pub use show::sh::ow;  // 层层扒皮到最顶层，类似define一个名字代表另一个多级结构下的函数
}

fn main(){
	class_a::ow(); // 直接从mod后调用
}

demo：

1.mod with struct

mod中结构体默认为private，需要公开结构体路径，同时结构体字段默认也为private。
如要访问结构体字段，需要将该字段设置为public。

mod student{
    pub struct Stu{
        id:u32,				//id默认为private ， 不可以被外部函数访问
        pub name:String,	// name 字段是public的，可以被外部函数访问
    }
    impl Stu{
        pub fn new_stu(name:&str)->Stu{   // 类似构造函数，name public是可以通过外部传参来修改的。id为private ，无法被直接修改
            Stu{
                id:999,
                name:String::from(name),
            }
        }
        pub fn set_id(&mut self,id:u32){  // Private 字段只能被同一包内访问，同时若要修改，需要传入mut参数，否则字u32、str等是不可被修改的
            self.id = id ;
        }
        pub fn get_id(&self )->u32{  // 私有字段的访问方式
            self.id
        }
    }
}

pub fn change_name(){
    let mut s1 = student::Stu::new_stu("name_ori");
//  println!("id = {}",s1.id);//error  , private id  // 私有字段无法被直接访问
    println!("name = {}",s1.name);	//公有字段可以被直接访问
    s1.set_id(1000);	//私有字段的修改，需要定义mut参数，只能修改mut参数，不能修改str等字段
    let id = s1.get_id();
    println!("id = {}",id);
}

fn main() {
    change_name();
}

2.mod with enum

enum只要public，则内部都为pub，可以被直接访问，如下：

─
mod class{
    pub enum Sta{
        Ret{
            sta:u32,
        },
        Nothing,
    }
}
fn enum_demo(){
    let ret = class::Sta::Ret{sta:1}; // Ret及其字段，可以访问。
    match ret {
        class::Sta::Ret{sta} =>{
            println!("get sta : {}",sta);
        }
        _ => {}
    }
}

3.use + as + pub

mod class_a{
    // for use
    pub fn show_a(){
        println!("class_a::show_a()");
    }
    // for use + as
    pub mod show_info{
        pub fn show_a(){
            println!("class_a::show_info::show_a()");
        }
    }
    // for pub + use
    pub mod show{
        pub mod sh{
            pub fn ow(){
                println!("class_a::show::sh::ow()");
            }

        }
    }
    pub use show::sh::ow;
}

use crate::class_a::show_a;
use crate::class_a::show_info::show_a as show_b;

fn main() {
    func::show_1(1000);

    show_a();
    show_b();
    class_a::ow();

}