不安全代码

内存安全/不安全函数

默认情况下:

所有的V函数调用都是内存安全的,可信的,

所有的C函数调用都是内存不安全的,不可信的,

如果要把某个V函数定义为内存不安全的,要给函数加上unsafe注解,

如果要把C函数定义为内存安全的,可信的,要给函数加上trusted注解,

不管是V函数还是C函数,所有内存不安全的函数都要在unsafe代码块中调用,否则编译器会报错.

1. [unsafe] //注解V函数为不安全的函数,因为里面有手动的内存控制或指针运算等内存不安全操作
2. pub fn (a array) free() {
3. //if a.is_slice {
4. //return
5. //}
6. C.free(a.data)
7. }

1. // v/builtin/cfns.c.v
2. [trusted] //注解C函数为安全的,信任的函数
3. fn C.calloc(int, int) &byte

5. fn C.malloc(int) &byte

7. fn C.realloc(a &byte, b int) &byte

9. fn C.free(ptr voidptr)

11. [trusted]
12. fn C.exit(code int)

unsafe函数必须在unsafe代码块中调用

1. fn my_fn() {
2. unsafe {
3. //在这里才能调用不安全函数
4. }
5. //在unsafe代码块之外调用,编译器会警告
6. }

在不安全代码块中进行指针运算和多级指针,编译器啥都不管,自己掌控,就跟C一样

1. module main

3. fn main() {
4. unsafe {
5. v := 4
6. mut p := &v
7. // unsafe代码块中可以进行指针运算,编译器不负责检查
8. p++
9. p += 2
10. p = p - 1
11. println(p)
12. p = p + 1
13. println(p)
14. r := p++
15. println(r)
16. //多级指针
17. n := 100
18. pn := &n
19. ppn := &pn
20. mut pppn := &ppn
21. println(pppn)
22. }
23. }

不安全表达式

1. module main

3. fn main() {
4. mut q := &byte(10)
5. println(q)
6. unsafe {
7. q -= 2
8. q = q + 1
9. }
10. println(q)
11. //不安全表达式,返回指针运算后的结果
12. s := unsafe { q - 1 }
13. println(s)
14. unsafe {
15. q++
16. q++
17. q--
18. }
19. println(q)
20. }