Technology sharing

Salve omnis

Hodie complevi 2024 Autonomum Coegi OS Development Training Camp - Quartum Phase Campi Elementarii - Tutorialis

Day2 Practice rubigo linguarum cum crepitu-move Semantics

https://doc.rust-lang.org/stable/book/ch04-00-understanding-ownership.html

Cum codicem subicio, nuntium accipio quem non permittitur.

aciton

Relatio progressionem amet configuratione

https://rcore-os.cn/arceos-tutorial-book/ch01-02.html

mihi topic

https://github.com/cicvedu/rustlings-semester-4-watchpoints

Fac clavem ssh ad clone in github codice via ssh. In ambitu Linux, ssh-keygen -t rsa -b 4096 -C "mailbox tuum" mandatum ut clavis ssh crearet. Tum uti cattus ~/.ssh/id_rsa.pub

Primitivae species

Rubigo duo genera fundamentalium habet quae in compilator directe implentur. In hac sectione per maximas ibimus.

Praeterea notitia

• Data Genera
• Verre Type

Slice Type Slices let you reference a contiguous sequence of elements in a collection rather than the whole collection.

Segmentum est genus relationis, unde dominium non habet.

In Rust, scalpere visum est quod consequentiam elementorum contiguorum ex acie vel alio segmento notat. Ad segmentum creare, initium et finem positionum segmenti denotare debes (non addito indice positionis finis).in ordinataa in si vis accipere[2, 3, 4] Huic segmento, debes indicem 1 incipere et finem in indice 4 (excluso indice 4).

Ecce quomodo figere test codice tuo:

#[test]
fn slice_out_of_array() {
    let a = [1, 2, 3, 4, 5];

    // 从索引 1 开始，到索引 4 结束的切片
    let nice_slice = &a[1..4];

    assert_eq!([2, 3, 4], nice_slice);
}

  
  
1

In hoc exemplo;&a[1..4] Creatum est ordinata exa Segmentum ad indicem 1 incipit et ad indicem 3 desinit, quia Rubigo syntaxis incisa est intervallum sinistrum clausum et rectum apertum (inclusum initium sed non finis).sicnice_slice Continet ordinataa medium[2, 3, 4]。

Intra crepitus in linea mandatorum vigilate ut experimentum ansa initium emendi codicis

intellectus Occupatio

Occupatio Rust singularis notae est ac penitus implicationes habet ad reliquam linguam.

Valet rubigo ad salutem memoriam tutos tutos non indigere purgamento collecto

Quid est Occupatio?

Dominium regit Primum, praecepta dominii inspice. Has regulas in mente custodimus sicut operamur per exempla, quae illustrant;

• Quilibet valor in Rust dominum habet.
• Non potest esse nisi unus dominus ad tempus.
• Cum dominus e scopo exit, valor omittetur

Exemplar ipsum codicem verum est et notiones dominii demonstrat et exscribendi in Rust. Attamen, si vis efficere codicem tuum congero et currit, et vis aliquas emendationes vel correctiones fieri, hic nonnullae suggestiones sunt;

1. face certum takes_ownership etmakes_copy munus inmain munus prius definitumquia functiones in Rust prius declarari ac deinde uti oportet.

2. notas adde, quare explicate s existtakes_ownership non potest esse posteaquam vocatus, etx existmakes_copy Potest tamen usus esse posteaquam vocatus.

3. Add to main munus reditus genusquamvis id in simplicibus programmatis non sit necessarium, est bene programmandi praxis.

4. Formatting tools utens Rust, exempli gratia rustfmtut mundum codicem servarent.

Hic modificatur signum ex superioribus suggestionibus:

fn takes_ownership(some_string: String) { // 函数定义在 main 之前
    println!("{}", some_string);
} // some_string 的作用域结束，调用 Drop

fn makes_copy(some_integer: i32) { // 函数定义在 main 之前
    println!("{}", some_integer);
} // some_integer 的作用域结束，没有调用 Drop，因为 i32 是 Copy 类型

fn main() -> () { // 明确 main 函数的返回类型为 ()
    let s = String::from("hello");  // s 拥有 "hello" 的所有权

    takes_ownership(s);             // s 的值移动到 takes_ownership 函数

    // 下面的代码尝试使用 s 将会导致编译错误，因为 s 的值已经移动
    // let len = s.len(); // 错误：s 已移动

    let x = 5;                      // x 包含值 5

    makes_copy(x);                  // x 的值被复制到 makes_copy 函数
                                    // x 仍然有效，因为 i32 是 Copy 类型

    // x 仍然可以使用
    println!("x is {}", x);
}

  
  
1

In hac versione recognita adiecimus main munus reditus genus(),hoc significat main Munus nullum reddit valorem.Etiam, glossae additae sunt ad explicandum quares existtakes_ownership non potest esse posteaquam vocatus, etx existmakes_copy Valet adhuc vocatum.Accedit, quod conamina demonstramustakes_ownership Utere cum vocationes Exempla quae compilationem erroris causant, etx existmakes_copy Exempla quae post vocationem adhuc adhiberi possunt.

Vectors

Vectors sunt unum ex maxime adhibitum Rust notitia structurae.

In aliis programmatibus, Arrays simpliciter dici volunt, sed quia Rubigo in aliquantulum inferioris gradus operatur, in ACERVUS ordinatus in rubigo reponitur (id est non potest crescere vel detrectare, et cognosci debet magnitudo. tempore compilare), et vector in acervo reponitur (ubi haec restrictiones non valent).

Vectors sunt aliquantulum posterioris capitis in libro, sed putamus eos satis utiles esse de illis loqui paulo ante. Loquemur de aliis utilibus instrumentis, mappis cinematographicis, posterius.

Praeterea notitia

• Repono Index Pretio cum Vectors
• iter_mut
• map

vec_map Munus est accipere aVec<i32> typus (i.e. vector continens XXXII frenum integer), deinde redit novumVec<i32>unumquodque elementum in novo vectore bis est magnitudo elementi respondentis in vectore originali.

Speciatim,vec_map in munusmap etcollect Modus operatur sic:

1. **v.iter()**: Hoc modo creat iterator qui percurrit v unumquodque elementum vector.iter Reversus iterator per modum immutabilem praebet comparationem elementorum vectoris.

2. **.map(|element| { element * 2 })**：map Modus clausuram accipit (munus anonymum), hoc in casu clausurae unam accipit modulumelement (immutabilis relatio elementi vectoris) et dein valorem multiplicatum huius elementi refert 2.Res intus commissuraselement * 2 Re quidem vera notitia demonstrata dereferencing per relationem (via* operator) et multiplicationem operationes.

3. **.collect()**：map Modus iterator ignavus redit qui operationes in clausurae singulatim applicat, sed eventus statim non colligit.collect modus est ut haecmap Processionaliter in novum elementa colligunturVec<i32> in vector.

usus map etcollect Beneficium est quod permittunt te operationes in singulis elementis in collectione declarativo modo exercere et eventus colligere in nova collectione sine necessitate ansulas expressas scribere. Hoc modo in codice brevius et magis consentaneum est Rust stylum.

Hic est quomodo utendi vec_map Exemplum functionis:

fn main() {
    let original_vec = vec![1, 2, 3, 4];
    let doubled_vec = vec_map(&original_vec);
    println!("{:?}", doubled_vec); // 这将打印：[2, 4, 6, 8]
}

  
  
1

In hoc exemplo;vec_map capereoriginal_vec reference, novum vectordoubled_vecquae bis valorem cuiusque elementi archetypi vectoris continet et imprimit.

Movere Semantics

Haec exercitia aptantur ex pnkfelix's Rubigo Tutorial -- Thank you Felix!!!

Praeterea notitia

Ad hanc sectionem, libri nexus maxime momenti sunt.

• Dominium
• Reference et mutuo acceperam

move_semantics1.rs

move_semantics2.rs

// move_semantics5.rs

Regula mutabilium notionum in Rubigo exstat: quovis tempore, quotcunque notationes immutabiles, vel ad summum unam mutabilem referentiam habere potes. Haec regula memoriam salutem praestat et notitias gentium prohibet.

In codice provisum est quaestio:main Munus mutabile references creare conatusy etz, x . Hoc non licet, quia Rubigo praecepta mutuata non patitur multiplices notationes mutabiles in eodem scopo variabiles. Ideo signum non compilare.

Ad hanc quaestionem figere, debes efficere ut una tantum relatio mutabilis quolibet tempore existat. Hic certum est codicem:

fn main() {
    let mut x = 100;
    {
        let y = &mut x;
        *y += 100; // 此时 x 的值变为 200
    } // 'y' 的作用域结束，可变引用被销毁
    {
        let z = &mut x; // 可以创建新的可变引用，因为 'y' 已经不存在了
        *z += 1000; // 此时 x 的值变为 1200
    } // 'z' 的作用域结束，可变引用被销毁
    assert_eq!(x, 1200); // 断言 x 的值是 1200，这是正确的
}

  
  
1

In hac certa versione cavemus ut una tantum relatio mutabilis aliquo tempore creando interiorem scopum exsistat.Primum, nos creavity scopa, operatio in eo, et haec scopus;y Non valet ultra.Post hoc, nos creavitz scope, iterum forx Operationes conficere. Hoc Rust praecepta mutuata sequitur ut codicem conscribit et currit ut expectatur.

Haec compilatio errorum nuntium ostendit ad exitum vitae in Rust codice.Quaestio eststring_uppercase In exsequendo munere tempus valorem ad relationem assignare conatur, quod non licet.

Hic linea codicis siet;

data = &data.to_uppercase();

  
  
1

Hic versus in codice;data.to_uppercase() Creatum aString Novum instantiadata mutuo acceperam.Tamen, conare assignare comparationem huius valoris temporalisdata illicitum est quod ad tempus valorem statim in fine constitutionis destruitur etdata Longiorem vitam requirit quam bona temporalia.

Ad hanc quaestionem figere opus est ut mitigare string_uppercase Munus, quod mutabilem comparationem accipit, eam vocat directe in notitia quae ab illo referente demonstrata estmake_uppercase() modum pro conatur resignare. Hic certum est codicem:

fn string_uppercase(data: &mut String) {
    data.make_uppercase(); // 直接在 data 上调用 make_uppercase 方法

    println!("{}", data);
}

  
  
1

In hac certa versione nos removimus mut data: &String mediummut,quod data mutabilis iam relatio.Deinde rectadata vocate onmake_uppercase(), sic nulla erit difficultas de bonis temporalibus.make_uppercase() Modus immutabiturdata signis toString exempli gratia sine novoString。

etiam,main Vocatio intra munus etiam renovari debet proinde ut relatio mutabilis fiat:

fn main() {
    let mut data = "Rust is great!".to_string();

    string_uppercase(&mut data); // 传递一个可变引用
    println!("{}", data); // 打印修改后的字符串
}

  
  
1

Nunc,string_uppercase munus accipitdata mutabilis relatio, eam directe modificans, etmain in munusdata mutabilis esse poteststring_uppercase mutari. Hoc modo codicem conficit et opera ut expectatur.

/**
【昵称】小王同学
【坐标】山东
【自我介绍】
    1. 高级后端工程师,擅长c++并发编程。
    2. 专注分布式存储，分布式数据库。
    3. 时间的践行者，立志成为一名讲师。
【我的成绩】
    1.  为了走出农村，2次高考
         一次考研失败,
         遇挫之后不知道干什么,开启被动之旅。
    2. 为了找到合适工作,   
        深入研究c++书籍和leetcode 200题目
    3. 为了提高项目能力，参与开源项目建设。
    4. 为了把简单事情说清楚/要干啥
        按照《只管去做》,《福格行为模型>>方法。
        纸上得来终觉浅，绝知此事要躬行
        做一个践行者。
【我能提供】
    1.  后端程序员的简历优化+就业辅导+职业规划
    2.  全栈工程师(c++,rust,go,python )项目开发
    3. 一年践行12本书践行记录。
【希望一起解决什么，开启破圈之旅】
    1. 交接更多朋友，抱团取暖。
        寻找意义本身就更加有意义。
    2. 无法做整个系统，聚焦一个模块
         道可道也，非恒道也 
         名可名也,非恒名也。
         无名 万物之始也
         有名 万物之母也
         别想太多，只管去做，躬身入局
     
链接我： # + v（github):watchpoints   
        #众号：后端开发成长指南
**/

  
  
1