type-conversions/as #173

2022-03-28T06:51:00Z

giscus[bot]
bot Mar 28, 2022

type-conversions/as

Learning Rust By Practice, narrowing the gap between beginner and skilled-dev with challenging examples, exercises and projects.

https://zh.practice.rs/type-conversions/as.html

jingth · 2022-10-03T15:08:08Z

jingth
Oct 3, 2022 — with giscus

/* 我的答案
// 修复错误，填空
// 不要移除任何代码
1........................................................................
fn main() {
let decimal = 97.123_f32;

let integer = decimal as u8;

let c1 = decimal as u8;
let c2 = integer as char;

assert_eq!(integer, 'a' as u8);

println!("Success!")

}
*/

2.....很抱歉，第2题不会
/*
fn main() {
assert_eq!(u8::MAX, 255);
// 如上所示，u8 类型允许的最大值是 255.
// 因此以下代码会报溢出的错误： literal out of range for u8.
// 请仔细查看相应的编译错误，从中寻找到解决的办法
// 不要修改 main 中的任何代码
let v:u8 = 1000 as u8;

println!("Success!")

}
*/

3.................................................................................
/*
fn main() {
assert_eq!(1000 as u16, 1000);

assert_eq!(1000_u16 as u8, 232);

// 事实上，之前说的规则对于正整数而言，就是如下的取模
println!("1000 mod 256 is : {}", 1000 % 256);

assert_eq!(-1_i8 as u8, 255);


// 从 Rust 1.45 开始，当浮点数超出目标整数的范围时，转化会直接取正整数取值范围的最大或最小值
assert_eq!(300.1_f32 as u8, 255);
assert_eq!(-100.1_f32 as u8, 0);


// 上面的浮点数转换有一点性能损耗，如果大家对于某段代码有极致的性能要求，
// 可以考虑下面的方法，但是这些方法的结果可能会溢出并且返回一些无意义的值
// 总之，请小心使用
unsafe {
    // 300.0 is 44
    println!("300.0 is {}", 300.0_f32.to_int_unchecked::<u8>());
    // -100.0 as u8 is 156
    println!("-100.0 as u8 is {}", (-100.0_f32).to_int_unchecked::<u8>());
    // nan as u8 is 0
    println!("nan as u8 is {}", f32::NAN.to_int_unchecked::<u8>());
}

}
*/

4...........................................................................
/*
// 填空
fn main() {
let mut values: [i32; 2] = [1, 2];
let p1: *mut i32 = values.as_mut_ptr();
let first_address: usize = p1 as usize;
let second_address = first_address + 4; // 4 == std::mem::size_of::()
let p2: *mut i32 = second_address as *mut i32; // p2 指向 values 数组中的第二个元素
unsafe {
// 将第二个元素加 1
*p2 += 1;
}

assert_eq!(values[1], 3);

println!("Success!")

}
*/

5....................................................................
/*
fn main() {
let arr :[u64; 13] = [0; 13];
assert_eq!(std::mem::size_of_val(&arr), 8*13);
let a: *const [u64] = &arr;
let b = a as *const [u8];
unsafe {
assert_eq!(std::mem::size_of_val(&*b), 13)
}
}
*/

0 replies

Apahno · 2022-10-08T00:42:41Z

Apahno
Oct 8, 2022 — with giscus

第2题
#![allow(overflowing_literals)]
fn main() {
assert_eq!(u8::MAX, 255);
// 如上所示，u8 类型允许的最大值是 255.
// 因此以下代码会报溢出的错误： literal out of range for u8.
// 请仔细查看相应的编译错误，从中寻找到解决的办法
// 不要修改 main 中的任何代码
let v = 1000 as u8;

println!("Success!")

}

0 replies

ADkun · 2022-10-09T08:26:34Z

ADkun
Oct 9, 2022 — with giscus

第1题

// 修复错误，填空
// 不要移除任何代码
fn main() {
    let decimal = 97.123_f32;

    let integer: u8 = decimal as u8;

    let c1: char = integer as char;
    let c2 = integer as char;

    assert_eq!(integer, 'a' as u8);

    println!("Success!")
}

第2题

fn main() {
    assert_eq!(u8::MAX, 255);
    // 如上所示，u8 类型允许的最大值是 255.
    // 因此以下代码会报溢出的错误： literal out of range for `u8`.
    // **请仔细查看相应的编译错误，从中寻找到解决的办法**
    // **不要修改 main 中的任何代码**
    #[allow(overflowing_literals)]
    let v = 1000 as u8;

    println!("Success!")
}

第3题

fn main() {
    assert_eq!(1000 as u16, 1000);

    assert_eq!(1000_u16 as u8, (1000_u16 % (u8::MAX as u16 + 1)) as u8);

    // 事实上，之前说的规则对于正整数而言，就是如下的取模
    println!("1000 mod 256 is : {}", 1000 % 256);

    assert_eq!(-1_i8 as u8, u8::MAX);
    

    // 从 Rust 1.45 开始，当浮点数超出目标整数的范围时，转化会直接取正整数取值范围的最大或最小值
    assert_eq!(300.1_f32 as u8, u8::MAX);
    assert_eq!(-100.1_f32 as u8, u8::MIN);
    

    // 上面的浮点数转换有一点性能损耗，如果大家对于某段代码有极致的性能要求，
    // 可以考虑下面的方法，但是这些方法的结果可能会溢出并且返回一些无意义的值
    // 总之，请小心使用
    unsafe {
        // 300.0 is 44
        println!("300.0 is {}", 300.0_f32.to_int_unchecked::<u8>());
        // -100.0 as u8 is 156
        println!("-100.0 as u8 is {}", (-100.0_f32).to_int_unchecked::<u8>());
        // nan as u8 is 0
        println!("nan as u8 is {}", f32::NAN.to_int_unchecked::<u8>());
    }
}

第4题

// 填空
fn main() {
    let mut values: [i32; 2] = [1, 2];
    let p1: *mut i32 = values.as_mut_ptr();
    let first_address: usize = p1 as usize; 
    let second_address = first_address + 4; // 4 == std::mem::size_of::<i32>()
    let p2: *mut i32 = second_address as *mut i32; // p2 指向 values 数组中的第二个元素
    unsafe {
        // 将第二个元素加 1
        *p2 += 1;
    }
    
    assert_eq!(values[1], 3);

    println!("Success!")
}

第5题

fn main() {
    let arr :[u64; 13] = [0; 13];
    assert_eq!(std::mem::size_of_val(&arr), 8 * 13);
    let a: *const [u64] = &arr;
    let b = a as *const [u8];
    unsafe {
        assert_eq!(std::mem::size_of_val(&*b), 13)
    }
}

3 replies

wangshankun Nov 17, 2022 — with giscus

不太理解这段, 难道切片的类型转换，len保持不变吗？
assert_eq!(std::mem::size_of_val(&*b), 13)

wangshankun Nov 17, 2022 — with giscus

unsafe {	
  println!("{}",(&*b).len()); //13， 
 //也就是b = a as *const [u8]，只是将胖指针的修饰由u64改为u8，而胖指针的len依旧不变；
  println!("{}",(&*a).len());//13
}

twandylue Dec 13, 2022 — with giscus

In this case, since the original [u64] array has 13 elements, the [u8] array also has 13 elements, so the size of the array would be 1 x 13 = 13 bytes.

Bruce012356 · 2023-01-07T02:41:36Z

Bruce012356
Jan 7, 2023 — with giscus

mark

0 replies

asd123wto · 2023-02-06T09:46:00Z

asd123wto
Feb 6, 2023 — with giscus

第四题指针没弄懂有没有大佬讲解一下

0 replies

runzhi214 · 2023-07-26T04:53:55Z

runzhi214
Jul 26, 2023 — with giscus

第三题

#[allow(overflowing_literals)]
fn main() {
    /*
     * 1000 i32 即 0000 0000 0000 0000 0000 0011 1110 1000
     * u16截取 -> 0000 0011 1110 1000
     * u8截取 -> 1110 1000 -> 1000 - 512 - 256 = 232
     */
    assert_eq!(1000 as u16, 1000);

    assert_eq!(1000 as u8, 232);

    // 事实上，之前说的规则对于正整数而言，就是如下的取模
    println!("1000 mod 256 is : {}", 1000 % 256); // =232

    // 表示法： 正数 => 负数， 取反 + 1
    // 1 => 0000 0001 => 1111 1110 => 1111 1111
    // 是为了保证 +1 + (-1) =0
    assert_eq!(-1_i8 as u8, 255);


    // 从 Rust 1.45 开始，当浮点数超出目标整数的范围时，转化会直接取正整数取值范围的最大或最小值
    assert_eq!(300.1_f32 as u8, 255);
    assert_eq!(-100.1_f32 as u8, 0);
    
    
    // 上面的浮点数转换有一点性能损耗，如果大家对于某段代码有极致的性能要求，
    // 可以考虑下面的方法，但是这些方法的结果可能会溢出并且返回一些无意义的值
    // 总之，请小心使用
    unsafe {
        // 300.0 is 44
        println!("300.0 is {}", 300.0_f32.to_int_unchecked::<u8>());
        // -100.0 as u8 is 156
        println!("-100.0 as u8 is {}", (-100.0_f32).to_int_unchecked::<u8>());
        // nan as u8 is 0
        println!("nan as u8 is {}", f32::NAN.to_int_unchecked::<u8>());
    }
}

2 replies

runzhi214 Jul 26, 2023 — with giscus

再解释一下-100 as u8 得到 156

        // -100.0 as u8 is 156
        // -100.0 => int -100 => 1001 1100 => u8 156
        // 0b10011100 as u8 => 156
        // 0b10011100 as i8 => -100
        println!("-100.0 as u8 is {}", (-100.0_f32).to_int_unchecked::<u8>());
    }

runzhi214 Jul 26, 2023 — with giscus

第二题

编译器告知默认开启deny,改成allow即可

#[allow(overflowing_literals)]
fn main() {
    assert_eq!(u8::MAX, 255);
    // 如上所示，u8 类型允许的最大值是 255.
    // 因此以下代码会报溢出的错误： literal out of range for `u8`.
    // **请仔细查看相应的编译错误，从中寻找到解决的办法**
    // **不要修改 main 中的任何代码**
    let v = 1000 as u8;

    println!("Success!")
}

第5题

u64 8bit => u8 1bit
因此1 * 13

tokisakiyuu · 2023-07-29T04:55:04Z

tokisakiyuu
Jul 29, 2023 — with giscus

FBI WARNING

我的评价是
  某些不使用markdown语法代码块发代码片段的
  你们就是一字千金也臭不可闻
    不要发出来污染眼睛
    没多少人想看
      你喜欢朴实无华 ?
        那推荐到你那原始丛林一般的windowxp桌面
        挖一个名为"新建文本.txt"的土坑
        精   雕   细   拉

0 replies

chenhai998 · 2023-08-06T13:52:15Z

chenhai998
Aug 6, 2023 — with giscus

done

0 replies

Ghy0202 · 2023-08-23T06:10:44Z

Ghy0202
Aug 23, 2023 — with giscus

1、as的用法

fn main() {
    let decimal = 97.123_f32;

    let integer:u8 = decimal as u8;

    let c1: char = (decimal as u8) as char;//在rust中只有u8可以转成char
    let c2 = integer as char;

    assert_eq!(integer, 'a' as u8);//左边的值是97对应的ascii符号是‘a’

    println!("Success!")
}

2、关闭deny-by-default，第二题代码报错的原因是rust编译器默认开启了溢出报错的设置，只需要在main之前加一行#[allow(overflowing_literals)]允许溢出即可

#[allow(overflowing_literals)]
fn main() {
    assert_eq!(u8::MAX, 255);
    // 如上所示，u8 类型允许的最大值是 255.
    // 因此以下代码会报溢出的错误： literal out of range for `u8`.
    // **请仔细查看相应的编译错误，从中寻找到解决的办法**
    // **不要修改 main 中的任何代码**
    let v = 1000 as u8;

    println!("Success!")
}

3、这题感觉也是加上前缀允许溢出后，对值的判断（可以借助编译器）

#[allow(overflowing_literals)]
fn main() {
    assert_eq!(1000 as u16, 1000);

    assert_eq!(1000 as u8,232);

    // 事实上，之前说的规则对于正整数而言，就是如下的取模
    println!("1000 mod 256 is : {}", 1000 % 256);

    assert_eq!(-1_i8 as u8, 255);
    

    // 从 Rust 1.45 开始，当浮点数超出目标整数的范围时，转化会直接取正整数取值范围的最大或最小值
    assert_eq!(300.1_f32 as u8, 255);
    assert_eq!(-100.1_f32 as u8, 0);
    

    // 上面的浮点数转换有一点性能损耗，如果大家对于某段代码有极致的性能要求，
    // 可以考虑下面的方法，但是这些方法的结果可能会溢出并且返回一些无意义的值
    // 总之，请小心使用
    unsafe {
        // 300.0 is 44
        println!("300.0 is {}", 300.0_f32.to_int_unchecked::<u8>());
        // -100.0 as u8 is 156
        println!("-100.0 as u8 is {}", (-100.0_f32).to_int_unchecked::<u8>());
        // nan as u8 is 0
        println!("nan as u8 is {}", f32::NAN.to_int_unchecked::<u8>());
    }
}

4、见教程示例

// 填空
fn main() {
    let mut values: [i32; 2] = [1, 2];
    let p1: *mut i32 = values.as_mut_ptr();
    let first_address: usize = p1 as usize; 
    let second_address = first_address + 4; // 4 == std::mem::size_of::<i32>()
    let p2: *mut i32 = second_address as *mut i32; // p2 指向 values 数组中的第二个元素
    unsafe {
        // 将第二个元素加 1
        *p2+=1;
    }
    
    assert_eq!(values[1], 3);

    println!("Success!")
}

5、可以用编译器报错得到答案，我的理解是rust针对数组的类型转换应用到了数组的每一个元素，即从u64变成u8,输出结果是数组占据的空间的大小

fn main() {
    let arr :[u64; 13] = [0; 13];//[0,0,……0]
    assert_eq!(std::mem::size_of_val(&arr), 8 * 13);
    let a: *const [u64] = &arr;//assert_eq!(std::mem::size_of_val(&a), 8 * 2);
    // unsafe{
    //     assert_eq!(std::mem::size_of_val(&*a), 8 * 13);
    // }
    let b = a as *const [u8];//u8的大小是1
    unsafe {
        assert_eq!(std::mem::size_of_val(&*b), 1*13)
    }
}

0 replies

iamtaojin · 2023-12-11T14:33:02Z

iamtaojin
Dec 11, 2023 — with giscus

第一题

#[allow(unused)]
// 修复错误，填空
// 不要移除任何代码
fn main() {
    let decimal = 97.123_f32;

    let integer: u8 = decimal as u8;

    let c1: char = decimal as u8 as char;
    let c2 = integer as char;

    assert_eq!(integer+1, 'b' as u8);

    println!("Success!")
}

第二题

fn main() {
    assert_eq!(u8::MAX, 255);
    // 如上所示，u8 类型允许的最大值是 255.
    // 因此以下代码会报溢出的错误： literal out of range for `u8`.
    // **请仔细查看相应的编译错误，从中寻找到解决的办法**
    // **不要修改 main 中的任何代码**
    let v = 1000_u16 as u8;

    println!("Success!")
}

第三题

fn main() {
    assert_eq!(1000 as u16, 1000);

    assert_eq!(1000_u16 as u8, (1000_u16%(u8::MAX as u16 +1)) as u8);

    // 事实上，之前说的规则对于正整数而言，就是如下的取模
    println!("1000 mod 256 is : {}", 1000 % 256);

    assert_eq!(-1_i8 as u8, u8::MAX);
    

    // 从 Rust 1.45 开始，当浮点数超出目标整数的范围时，转化会直接取正整数取值范围的最大或最小值
    assert_eq!(300.1_f32 as u8, u8::MAX);
    assert_eq!(-100.1_f32 as u8, 0);
    

    // 上面的浮点数转换有一点性能损耗，如果大家对于某段代码有极致的性能要求，
    // 可以考虑下面的方法，但是这些方法的结果可能会溢出并且返回一些无意义的值
    // 总之，请小心使用
    unsafe {
        // 300.0 is 44
        println!("300.0 is {}", 300.0_f32.to_int_unchecked::<u8>());
        // -100.0 as u8 is 156
        println!("-100.0 as u8 is {}", (-100.0_f32).to_int_unchecked::<u8>());
        // nan as u8 is 0
        println!("nan as u8 is {}", f32::NAN.to_int_unchecked::<u8>());
    }
}

第四题

// 填空
fn main() {
    let mut values: [i32; 2] = [1, 2];
    let p1: *mut i32 = values.as_mut_ptr();
    let first_address: usize = p1 as usize; 
    let second_address = first_address + 4; // 4 == std::mem::size_of::<i32>()
    let p2: *mut i32 = second_address as *mut i32; // p2 指向 values 数组中的第二个元素
    unsafe {
        // 将第二个元素加 1
        *p2 += 1;
    }
    
    assert_eq!(values[1], 3);

    println!("Success!")
}

第五题

fn main() {
    let arr :[u64; 13] = [0; 13];
    assert_eq!(std::mem::size_of_val(&arr), 8 * 13);
    let a: *const [u64] = &arr;
    let b = a as *const [u8];
    unsafe {
        assert_eq!(std::mem::size_of_val(&*b), 13)
    }
}

0 replies

TDAkory · 2024-07-21T03:21:05Z

TDAkory
Jul 21, 2024 — with giscus

mark finished

0 replies

zhhw · 2024-08-02T07:15:20Z

zhhw
Aug 2, 2024 — with giscus

没搞明白第五题为什么最后std::mem::size_of_val(&*b)的输出是13，我的理解是：a 和 b 都是裸指针，指向的是同一个内存地址（或者说一连串内存地址的起始位置），然后这块内存地址的大小是在arr初始化时开辟的，大小是 8*13=104，为什么转换成 *const [u8] 之后，size_of_val(&*b)就变成13了呢？如果返回的是元素个数，那么size_of_val(&*a) 也应该是13啊？

2 replies

zhhw Aug 2, 2024

fn main() {
    let arr :[u64; 13] = [1024; 13];
    println!("size of &arr: {}", std::mem::size_of_val(&arr));
    let a: *const [u64] = &arr;
    unsafe {
        println!("size of a: {}", std::mem::size_of_val(&*a));
        println!("{:?}", &*a);
    }
    let b = a as *const [u8];
    unsafe {
        println!("size of b: {}", std::mem::size_of_val(&*b));
        println!("{:?}", &*b);
        println!("{:?}", &*b.byte_offset(91));
    }
    let a = b as *const [u64];
    unsafe {
        println!("size of a: {}", std::mem::size_of_val(&*a));
    }
}

size of &arr: 104
size of a: 104
[1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024]
size of b: 13
[0, 4, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0]
[0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0]
size of a: 104

其中b和b.byte_offset(91)分别输出了：

[0, 4, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0]
[0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0]

这两个应该是arr 的内存地址开始处的数据和内存地址结束处的数据。

注：1024转换成16进制0x00000400，然后在内存中应该是存储为 00 04 00 00 这样。

但是也确实是没想明白这里面的转换规则是个什么情况。

我一开始的理解：b中不应该是有104个u8么？

zhhw Aug 2, 2024

想了下，猜测：
指针的结构是这样的[ptr, len, capacity]，然后指针a转成指针b，虽然数组中的数据类型从u64转成了u8，但是[ptr, len, capacity]这个结构是没有变化的，所以b指向的值就变成了ptr地址开始，往后len个长度的u8？

Lianghua007 · 2024-08-03T06:05:06Z

Lianghua007
Aug 3, 2024 — with giscus

第五题

fn main() {
    let arr: [u64; 13] = [0; 13];  // u64占8个字节
    assert_eq!(std::mem::size_of_val(&arr), 8 * 13);  // 计算给定引用所指向的值的大小
    let a: *const [u64] = &arr;  // 数组引用->裸指针(type1：*const T;  type2: *mut T)
    let b = a as *const [u8];  // 显示转换为*const[u8]裸指针
    unsafe {
        assert_eq!(std::mem::size_of_val(&*b), 13);  // 裸指针的操作，需要放在unsafe中运行
    }
}

1 reply

iamtaojin Nov 6, 2024 — with giscus

u64占8bit，13个8bit = 13*8 = 104。
u8占1bit, 13个1bit = 13。

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

type-conversions/as #173

{{title}}

Replies: 13 comments 8 replies

{{title}}

{{title}}

{{title}}

{{title}}

{{title}}

{{title}}

{{title}}

{{title}}

{{title}}

{{title}}

{{title}}

{{title}}

{{title}}

{{title}}

{{title}}

{{title}}

{{title}}

{{title}}

{{editor}}'s edit

{{editor}}'s edit

{{title}}

{{title}}

{{title}}

Select a reply

type-conversions/as #173

giscus[bot] bot Mar 28, 2022

type-conversions/as

Replies: 13 comments · 8 replies

jingth Oct 3, 2022 — with giscus

Apahno Oct 8, 2022 — with giscus

ADkun Oct 9, 2022 — with giscus

第1题

第2题

第3题

第4题

第5题

wangshankun Nov 17, 2022 — with giscus

wangshankun Nov 17, 2022 — with giscus

twandylue Dec 13, 2022 — with giscus

Bruce012356 Jan 7, 2023 — with giscus

asd123wto Feb 6, 2023 — with giscus

runzhi214 Jul 26, 2023 — with giscus

第三题

runzhi214 Jul 26, 2023 — with giscus

runzhi214 Jul 26, 2023 — with giscus

第二题

第5题

tokisakiyuu Jul 29, 2023 — with giscus

FBI WARNING

chenhai998 Aug 6, 2023 — with giscus

Ghy0202 Aug 23, 2023 — with giscus

iamtaojin Dec 11, 2023 — with giscus

TDAkory Jul 21, 2024 — with giscus

zhhw Aug 2, 2024 — with giscus

zhhw Aug 2, 2024

zhhw Aug 2, 2024

Lianghua007 Aug 3, 2024 — with giscus

第五题

iamtaojin Nov 6, 2024 — with giscus

giscus[bot]
bot Mar 28, 2022

Replies: 13 comments 8 replies

jingth
Oct 3, 2022 — with giscus

Apahno
Oct 8, 2022 — with giscus

ADkun
Oct 9, 2022 — with giscus

Bruce012356
Jan 7, 2023 — with giscus

asd123wto
Feb 6, 2023 — with giscus

runzhi214
Jul 26, 2023 — with giscus

tokisakiyuu
Jul 29, 2023 — with giscus

chenhai998
Aug 6, 2023 — with giscus

Ghy0202
Aug 23, 2023 — with giscus

iamtaojin
Dec 11, 2023 — with giscus

TDAkory
Jul 21, 2024 — with giscus

zhhw
Aug 2, 2024 — with giscus

Lianghua007
Aug 3, 2024 — with giscus