fn main()
{
let mut s = String::from("hello");
let ref1 = &s;
let ref2 = &ref1;
let ref3 = &ref2;
//s = String::from("goodboy"); //错误 s
println!("{}", ref3.to_uppercase());
}
fn drip_drop() -> String {
let s = String::from("hello,world");
//return &s; //错误
return s;
}
let s1 = String::from("hello");
let mut v = Vec::new();
v.push(s1);
//let s2: String = v[0]; //错误
let ref s2: String = v[0];
println!("{}",s2);
[package]
name = "helloworld"
version = "0.1.0"
authors = ["Jimmy Xiang <xxg1413@gmail.com>"]
edition = "2018"
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
[dependencies]
第二部分 Rust语法热身
let n:i32 = 1;
let n = 1;
//可变类型
let mut n = 0;
n = n + 1;
//Rust有两种字符串： &str和String
let s: &str = "hello,world"; //只读数据段
let mut s: String = String::from("hello,");
s.push_str("world");
println!("{}", s);
//动态数组
let mut v: Vec<i32> = Vec::new();
v.push(2);
v.push(3);
//固定大小数组
let mut arr: [i32; 4] = [0,2,4,8];
arr[0] = -2;
println!("{}", arr[0]+arr[1]);
//迭代器
for i in arr.iter()
{
println!("{}",i);
}
//while
let mut sum = 0;
let mut i = 0;
while i < 20
{
i += 1;
sum += i;
}
println!("sum={}",sum);
//loop 它有助于编译器对变量初始化进行一些假设。
let mut i = 0;
loop {
i += 1;
if i == 10 {
break;
}
}
println!("i={}",i);
//函数
fn mysum(a: i32, b:i32) -> i32
{
a + b //Rust是一种基于表达式的 语言，不需要分号
//a + b ; 会出错
}
println!("sum={}", mysum(1,2));
练习：
use std::collections::HashSet;
//练习
fn add_n(v: Vec<i32>, n: i32) -> Vec<i32> {
let mut result: Vec<i32> = Vec::new();
for i in v.iter() {
result.push(i+n)
}
result
}
fn add_n_inplace(v: &mut Vec<i32>, n: i32) {
let mut i = 0;
while i < v.len() {
v[i] = v[i] + n;
i = i + 1;
}
}
fn dedup(v: &mut Vec<i32>) {
let mut hs = HashSet::new();
let mut i = 0;
while i < v.len() {
if !hs.contains(&v[i]) {
hs.insert(v[i]);
i += 1;
} else {
v.remove(i);
}
}
}
#[cfg(test)]
mod test {
use super::*;
#[test]
fn test_add_n() {
assert_eq!(add_n(vec![1], 2), vec![3]);
}
#[test]
fn test_add_n_inplace() {
let mut v = vec![1];
add_n_inplace(&mut v, 2);
assert_eq!(v, vec![3]);
}
#[test]
fn test_dedup() {
let mut v = vec![3, 1, 0, 1, 4, 4];
dedup(&mut v);
assert_eq!(v, vec![3, 1, 0, 4]);
}
}
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
// There are at least 7 bugs relating to memory on this snippet.
// Find them all!
// Vec is short for "vector", a common term for a resizable array.
// For simplicity, our vector type can only hold ints.
typedef struct {
int* data; // Pointer to our array on the heap
int length; // How many elements are in our array
int capacity; // How many elements our array can hold
} Vec;
Vec* vec_new() {
Vec vec; //本地变量
vec.data = NULL;
vec.length = 0;
vec.capacity = 0;
return &vec; //悬浮指针
}
void vec_push(Vec* vec, int n) {
if (vec->length == vec->capacity) {
int new_capacity = vec->capacity * 2;
int* new_data = (int*) malloc(new_capacity);
assert(new_data != NULL);
for (int i = 0; i < vec->length; ++i) {
new_data[i] = vec->data[i];
}
vec->data = new_data; //忘记释放内存 内存泄露
vec->capacity = new_capacity;
}
vec->data[vec->length] = n; //指针的值改变了 n就改变了
++vec->length;
}
void vec_free(Vec* vec) {
free(vec);
free(vec->data);
}
void main() {
Vec* vec = vec_new();
vec_push(vec, 107);
int* n = &vec->data[0];
vec_push(vec, 110);
printf("%d\n", *n);//*n 迭代失效
free(vec->data);
vec_free(vec);// 双重释放
}
➜ 01 git:(main) ✗ valgrind --tool=memcheck --leak-check=full ./conver
==2022== Memcheck, a memory error detector
==2022== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al.
==2022== Using Valgrind-3.16.1 and LibVEX; rerun with -h for copyright info
==2022== Command: ./conver
==2022==
Enter a string:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
*** stack smashing detected ***: terminated
==2022==
==2022== Process terminating with default action of signal 6 (SIGABRT)
==2022== at 0x489C18B: raise (raise.c:51)
==2022== by 0x487B858: abort (abort.c:79)
==2022== by 0x48E63ED: __libc_message (libc_fatal.c:155)
==2022== by 0x4988B49: __fortify_fail (fortify_fail.c:26)
==2022== by 0x4988B15: __stack_chk_fail (stack_chk_fail.c:24)
==2022== by 0x109245: main (convert.c:22)
String in Upper Case = AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==2022==
==2022== HEAP SUMMARY:
==2022== in use at exit: 0 bytes in 0 blocks
==2022== total heap usage: 2 allocs, 2 frees, 2,048 bytes allocated
==2022==
==2022== All heap blocks were freed -- no leaks are possible
==2022==
==2022== For lists of detected and suppressed errors, rerun with: -s
==2022== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
[1] 2022 abort valgrind --tool=memcheck --leak-check=full ./conver
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
// There are at least 7 bugs relating to memory on this snippet.
// Find them all!
// Vec is short for "vector", a common term for a resizable array.
// For simplicity, our vector type can only hold ints.
typedef struct {
int* data; // Pointer to our array on the heap
int length; // How many elements are in our array
int capacity; // How many elements our array can hold
} Vec;
Vec* vec_new() {
Vec vec;
vec.data = NULL;
vec.length = 0;
vec.capacity = 0;
return &vec;
}
void vec_push(Vec* vec, int n) {
if (vec->length == vec->capacity) {
int new_capacity = vec->capacity * 2;
int* new_data = (int*) malloc(new_capacity);
assert(new_data != NULL);
for (int i = 0; i < vec->length; ++i) {
new_data[i] = vec->data[i];
}
vec->data = new_data;
vec->capacity = new_capacity;
}
vec->data[vec->length] = n;
++vec->length;
}
void vec_free(Vec* vec) {
free(vec);
free(vec->data);
}
void main() {
Vec* vec = vec_new();
vec_push(vec, 107);
int* n = &vec->data[0];
vec_push(vec, 110);
printf("%d\n", *n);
free(vec->data);
vec_free(vec);
}
Pxiaoer's Blog 