尝试以语法对照表格形式学习新语言：c,rust-Toy模板网

这篇具有很好参考价值的文章主要介绍了尝试以语法对照表格形式学习新语言：c,rust。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

以语法对照表格形式学习新语言，以rust为例。
关于rust的个人看法：文章来源地址https://www.toymoban.com/news/detail-826898.html

能否替代c？部分场景可以，长远看并不会。如果c再扩一些关键字，类似cpp的吸星大法式扩充，rust并不具备优势。
解决了c的内存管理问题？部分解决。所有权概念是将c中内存管理模式加了约束，并在编译期做了检查。
关于语言的生态位，个人感觉rust很难替代c的生态位。rust似乎是科研人员对c等语言进行研究后，加入了一些新的，实际上已有的概念。往往是编程实践中的范式，做了语言层面的语法支持。类似openmp扩展。
语言本质上逃不脱图灵机的定义，在最小实现基础上，为了方便、安全、开发效率等，加了编程范式的语法支持。
c、cpp语言已经做得够好，设计哲学也是效率至上，安全问题交给开发者负责。rust引入的所有权概念，在c、cpp中实际也可以用编程范式(智能指针)实现。
AI时代是否会出现最合适AI+人合作的语言？如果有，大概率会在c语言基础上扩展概念和范式。毕竟c的数据基础更好。个人倾向于认为rust有点过设计了。cpp过于复杂，也过设计了。个人感觉未来AI更适合使用以c为基础的语言，适当扩展一些概念。

	c	rust
链接	https://www.runoob.com/cprogramming/c-tutorial.html	https://www.runoob.com/rust/rust-tutorial.html
	https://www.runoob.com/cplusplus/cpp-tutorial.html	https://kaisery.github.io/trpl-zh-cn/title-page.html
标准库	stdio.h … https://www.runoob.com/cprogramming/c-standard-library.html	https://doc.rust-lang.org/stable/std/all.html
在线工具	https://www.runoob.com/try/runcode.php?filename=helloworld&type=c	https://play.rust-lang.org/?version=stable&mode=debug&edition=2021
		rust编译器依赖于c编译器
语言类型	面向过程	多范式：面向对象、函数式和并发编程
注释	// or /* */	// or /* */
行结尾	;	;
路径分隔符	/ or \	::
代码块	{}	{}
函数体表达式	无	{}
大小写	区分	同c
标识符	以字母 A-Z 或 a-z 或下划线 _ 开始，后跟零个或多个字母、下划线和数字（0-9）。	同c
关键字	https://www.runoob.com/cprogramming/c-basic-syntax.html	https://github.com/rust-lang/book/blob/main/src/appendix-01-keywords.md
keys	auto,break,case,char,const,continue,default,do,double,	as,async,await,break,const,continue,crate,dyn,else,enum,extern,
	else,enum,extern,float,for,goto,if,int,long,register,return,short,	false,fn,for,if,impl,in,let,loop,match,mod,move,mut,pub,ref,return,
	signed,sizeof,static,struct,switch,typedef,unsigned,union,void,volatile,while	Self,self,static,struct,super,trait,true,type,union,unsafe,use,where,while,
c99 keys	_Bool,_Complex,_Imaginary,inline,restrict	abstract,become,box,do,final,macro,override,priv,try,typeof,unsized,virtual,yield,
c11 keys	_Alignas,_Alignof,_Atomic,_Generic,_Noreturn,_Static_assert,_Thread_local
数据类型	char,unsigned char,signed char ,int,unsigned int,short,unsigned short,long,unsigned long	i8,u8,i16,u16,i32,u32,i64,u64,i128,u128,isize,usize
	float,double,long double	f32,f64,f128
	_Bool	bool
	void	无。空元组 () “unit type”
unicode	无	char(4byte)建议utf8
字符串	char str[] = “RUNOOB”;	let str = String::from(“RUNOOB”); let string = String::new(); let one = 1.to_string();
字符串切片	自行实现	let part1 = &str[0…5];//类似string_view
非字符串切片	自行实现	let part = &arr[0…3];
变量	int i=0;	let i:i32 = 0;
变量声明	extern int i;	extern { static i: i32;}
重影（Shadowing）	无	let x = 5; let x = x + 1;
左值	指向内存位置的表达式	同c
右值	存储在内存中某些地址的数值	同c
常量	long myLong = 100000L;float myFloat = 3.14f;char myChar = ‘a’;char myString[] = “Hello, world!”;	const MY_LONG: i64 = 100000; const MY_STRING: &str = “Hello, world!”; …
	#define PI 3.14159	const PI: f64 = 3.14159;
	const int MAX_VALUE = 100;	const MAX_VALUE:u32 = 100;
存储类型	auto,register,static,extern	static,extern
所有权	无	每个值都有一个变量，称为其所有者。一次只能有一个所有者。当所有者不在程序运行范围时，该值将被删除。
生命周期	{}代码块内	同c
静态生命周期	static	&'static
生命周期注释	无	描述引用生命周期。声明两个引用的生命周期一致。fn longer<'a>(s1: &'a str, s2: &'a str) -> &'a str{…}
移动（Move）	无	let s1 = String::from(“hello”);let s2 = s1; println!(“{}, world!”, s1); // 错误！s1 已经失效
克隆（Clone）	无	let s1 = String::from(“hello”);let s2 = s1.clone(); println!(“{}, world!”, s1);
算术运算符	+ -*/% ++ –	+ -*/%
关系运算符	== != > < >= <=	同c
逻辑运算符	&& \|\| !	同c
位运算符	& \| ^ ~ << >>	同c
赋值运算符	= += -= *= /= %= &= \|= ^= <<= >>=	同c
三元运算符	(a > 0)? 1:-1	if (a > 0) { 1 } else { -1 }
sizeof运算符	sizeof()	use std::mem; std::mem::size_of(…)
引用和解引用运算符	& *	& *
区间运算符	无	… …=
运算符优先级	https://www.runoob.com/cprogramming/c-operators.html
	用()改变求值顺序	同c
判断/条件语句	if(…){…}else{…}	if(…){…}else{…} 可以不要()，仅支持bool判断
switch分支判断	switch(…){case …:break;case …:break;default:…;}	无，用match替代
if let	无，用if替代	if let 0 = i {println!(“zero”);}else{…}
循环	for(;; ){} while(){} do{}while();	while(){} for i in a.iter(){…} loop{… break; …}
	break,continue	break,continue
	goto	无
函数定义	int max(int x, int y) {…}	fn max(x: i32, y: i32)->i32 {…}
函数嵌套	无	fn main() { fn five() -> i32 {5}}
函数调用	int ret = max(a, b);	let ret: i32 = max(a, b);
参数作用域	全局变量,局部变量,形式参数为局部变量	同c。多了借用（borrowing）和可变借用（mutable borrowing）概念
可变参数	… 具体示例见printf实现	无
数组	int i_array[] = {1, 2, 3, 4, 5};	let mut i_array: [i32; 5] = [1, 2, 3, 4, 5];
向量	无。用数组替代	let vector: Vec = Vec::new(); let vector = vec![1, 2, 4, 8];外加大量的方法。
数组下标	>=0	同c
数组访问	i_array[i]	i_array[i]
多维数组	int i_a2[3][3];	let mut i_a2: [[i32; 3]; 3] = [[0; 3]; 3];
动态数组	通过指针和malloc实现	let mut dynamic_array: Vec< i32 > = Vec::new();
map	无。自行实现。	use std::collections::HashMap;
指针	int *p=NULL;	无
引用	无	let s1 = String::from(“hello”);let s2 = &s1;
可变引用	无	let mut s1 = String::from(“run”);let s2 = &mut s1;
垂悬引用	无	编译期识别，eg:fn dangle() -> &String { let s = String::from(“hello”); &s}
地址	取地址方式&t	同c
函数指针	typedef int (*fun_ptr)(int,int);	let func_ptr: fn(i32,i32) -> i32;
枚举	enum DAY{ MON=1, TUE, WED, THU, FRI, SAT, SUN};	enum Book {Papery, Electronic} enum Book { Papery(u32), Electronic(String),}
枚举赋值	无	enum Book {Papery { index: u32 },Electronic { url: String },} let book = Book::Papery{index: 1001};
match	无，类似switch	match book {Book::Papery { index } => { println!(“Papery book {}”, index); }, Book::Electronic { url } => { println!(“E-book {}”, url); }}
NULL	NULL==0	无
Option枚举	无	替代NULL。enum Option< T > {Some(T), None,}
		let opt: Option<&str> = Option::None;match opt {Option::Some(something) => { println!(“{}”, something);}, Option::None => { println!(“opt is nothing”); }}
结构体	struct SIMPLE{ int a; char b; double c;};	struct SIMPLE{ a:i32; b:i8; c:f64;}
复合类型/元组	无	let tup: (i32, f64, u8) = (500, 6.4, 1);let (x, y, z) = tup;
元组结构体	无	struct Color(u8, u8, u8);let black = Color(0, 0, 0);
单元结构体	无	struct UnitStruct;//无成员
结构体成员访问	. 或 ->	只用. 没有->
结构体方法	无	struct Rectangle { width: u32, height: u32,} impl Rectangle { fn area(&self) -> u32 {self.width * self.height}}
结构体关联函数	无	impl Rectangle { fn create(width: u32, height: u32) -> Rectangle { Rectangle { width, height } }} //impl 可以写多次
输出结构体	无	println!(“rect1 is {:?}”, rect1);//属性较多的话可以使用另一个占位符 {:#?}
共用体	union Data{ int i; float f; char str[20];};	enum Data { Integer(i32), Float(f32), String([char; 20]),}
共用体成员访问	同结构体	match …
位域	struct bs{ int a:8; int b:2; int c:6;};	#[repr©] #[derive(Debug)] struct BitStruct { a: u8, b: u8, c: u8,}
位域成员访问	同结构体	同c
别名	typedef unsigned char BYTE;	type BYTE = u8;
程序入口	int main( int argc, char *argv[] )	fn main(){let args = std::env::args();println!(“{:?}”, args);}
输入	int scanf(const char *format, …) 函数从标准输入流 stdin 读取输入	stdin().read_line(&mut str_buf).expect(“Failed to read line.”);
输出	int printf(const char *format, …) 函数把输出写入到标准输出流 stdout	println!(“Your input line is \n{}”, str_buf);
文件读写	FILE fopen( const char filename, const char mode ); int fclose( FILE fp );int fputs( const char s, FILE fp );char fgets( char buf, int n, FILE *fp );fread(…)fwrite(…)…	use std::fs; let text = fs::read_to_string(“D:\text.txt”).unwrap(); let mut file = fs::File::open(“D:\text.txt”).unwrap(); file.read(&mut buffer).unwrap();fs::write(…) …
文件打开权限设置	const char *mode	let mut file = OpenOptions::new().read(true).write(true).open(“D:\text.txt”)?;
预处理	#define #include #undef #ifdef #ifndef #if #else #elif #endif	无，用宏替代
	#error	compile_error!
	#pragma	#[allow()] 和 #[warn()] 等
预定义宏	__DATE__ __TIME__ __FILE__ __LINE__ __STDC__	无。运行时有部分对应。
预处理器运算符	\ # ##	无
宏带参数	#define square(x) ((x) * (x))	macro_rules! square { ( $KaTeX parse error: Expected '}', got 'EOF' at end of input: x:expr) => { ($ x) * ($x) };}
头文件	#include <stdio.h> #include “my_head.h”	use std::io::stdin;
类型转换	int i=3;double d = (double)i;	let d: f64 = i as f64;
错误处理	extern int errno ;fprintf(stderr, “错误号: %d\n”, errno); perror(“通过 perror 输出错误”); fprintf(stderr, “错误号对应的描述: %s\n”, strerror( errno ));	可恢复错误用 Result<T, E> 类来处理，对于不可恢复错误使用 panic! 宏来处理。支持回溯。
回溯	非自带	支持。run with `RUST_BACKTRACE=1` environment variable to display a backtrace.
Result<T, E>	用int自行实现	enum Result<T, E> { Ok(T), Err(E),} 在 Rust 标准库中可能产生异常的函数的返回值都是 Result 类型的。
?符号	无	? 符仅用于返回值类型为 Result<T, E> 的函数
unwrap,expect	无	可恢复错误按不可恢复错误处理
除0	异常，崩溃	线程 panic，异常，崩溃
程序退出状态	exit(EXIT_SUCCESS); 0为正常状态。EXIT_FAILURE==-1	process::exit(0);
递归	一般通过递归函数实现	同c
内存管理	malloc free	通过所有权和智能指针（如 Box< T>、Rc< T> 和 Arc< T>）
命令行参数	int main( int argc, char *argv[] )	fn main()无，通过let args: Vec< String> = env::args().collect();获得
随机数	srand(time(0)) rand()	use rand::Rng; rand::rngs::StdRng::seed_from_u64(seed);rng.gen();
排序	void qsort(void *b, size_t n, size_t s, compar_fn cmp);	sort()
查找	void bsearch (const void __key, const void *__base, size_t __nmemb, size_t __size, __compar_fn_t __compar);	binary_search(t)
组织管理	.h.c.lib.dll …	箱（Crate）、包（Package）、模块（Module）
访问权	无	公共（public）和私有（private），默认私有，eg: pub mod government { pub fn govern() {} }
模块（Module）	无，有点像cpp的namespace	mod nation {mod government {fn govern() {}} mod congress {fn legislate() {}} mod court {fn judicial() {}}}
模块自描述	无	pub fn message() -> String { String::from(“This is the 2nd module.”)}// second_module.rs文件头
路径	无	绝对路径从 crate 关键字开始描述。相对路径从 self 或 super 关键字或一个标识符开始描述。
use	无	use crate::nation::government::govern as nation_govern;
泛型函数	_Generic	fn max< T >(array: &[T]) -> T {…}
泛型结构	无	struct Point< T > {x: T, y: T}
特性(trait)	无	trait Descriptive { fn describe(&self) -> String;} impl < 特性名 > for < 所实现的类型名 >
接口(Interface)	无。通过一组函数指针实现。	trait类似，但可以定义默认实现
继承	无。通过派生类包含基类成员实现	同c
多态	无。通过函数指针实现。	通过特性（trait）实现
并发(concurrent)	自行解决	安全高效的处理并发是 Rust 诞生的目的之一。编译期解决部分问题。
并行(parallel)	thread	openmp
线程(thread)	系统库	use std::thread;thread::spawn(…);
闭包	无，函数指针	\|arg1, arg2, …\| -> T {…}
Lambda	无，函数指针	无，闭包
实现消息	无	通道（channel）=发送者（transmitter）+接收者（receiver）。use std::sync::mpsc;let (tx, rx) = mpsc::channel();
代码例子	https://www.runoob.com/cprogramming/c-examples.html