rust编译教程

‘壹’ Rust 语法很丑陋吗如果是，为什么丑陋呢为什么设计成这样呢

Rust 的缩写是完全可以接受的嘛，也不是非常多，fn mod 这些都是很正常的缩写嘛,之前看到有人说 Rust 丑陋，应该是说指针语法繁杂，现在指针语法已经被统一和消除了（类型上来说貌似只有 & 是特殊的语法），一般使用是不会遇到让人厌恶的情景的。
This release also marks the complete removal of the `~` and `@` syntax in favor of library types `Box` and `Gc`.

- 0.11 changelog
原本语法中有 ~ 和 @ 前者是最普通的指针，后者是垃圾回收指针。
于是愈发会有奇葩的凌乱感，比如说

let foobar = 42i
&'a~@foobar // foobar 前面的都是指针

现在这些语法被范型代替了：
声明：

let foobar = 42i
&'a box Gc::new(foobar)

类型

&'a Box<Gc<int>>
虽然变长了但是更统一了。

当然我是从 0.11 开始学的，前面版本的语法我没用过，可能弄错。
题外话：
或许 Rust 是一个参与度最高的语言。
曾经有人评价，一个工程项目一般是：一开始是简洁但是不完善的，在第二次设计的时候是繁杂并完善的，进行了第三次设计才能变成简洁但是完善的。
我觉得 Rust 是在进行一个飞快的试错过程。Rust 在快速的迭代中不断的试错，变得复杂然后变得简单，每一个人都可以参与到语言的设计中去，只要你有干货辅佐你的观点，那么你只用写在 issues 里面就行了。Pull Requests · rust-lang/rfcs · GitHub
最重要的是在 1.0 发布之前，你的好想法都不会因为兼容性而被拒绝，也就是说没有任何兼容性包袱（这就是为什么 Rust 一直给人语法不稳定的印象），同时已经有不少人和不少项目正在用 Rust 书写，Rust 编译器本身和 Servo 都是非常庞大的项目，有几十万行级别的代码吧，语言中如果有什么常见的坑那么必然会被填平，我觉得或许会成为一个坑很少的语言。基本上我的代码编译通过了就不会有问题。
使用中遇到了坑请提交 iusses。

‘贰’ Rust正版开服 教程

开服准备】
有一个服务器，服务器建议去IDC机房的官网租用（网络 IDC机房 一大堆），淘宝黑心机房太多
一般4核8g内存 20m带宽 10-30g硬防就够了（以前要毛线硬防，现在只能呵呵）
=注意事项=
跟机房业务要说清楚下面几点
1.开UDP
2.对国外没有屏蔽
3.拿到服务器后速度改密码
4.等待服务端下载完毕，下载完后CMD会自动关闭
5.如果服务端没下载好，重新双击update即可
6.下载好后会出现一个rustds的文件夹 里面的就是RUST服务端了
7.双击打开，里面是这样的，这就是服务端
希望能帮到你，求采纳。

‘叁’ 为什么Rust这样的语言还需要C/C++编译器

需要用 VS 的链接器，应该是需要支持 FFI 的原因。Windows 是 Rust 承诺要支持的主要平台之一，这意味着，Rust要有能力和Windows上的静态库和动态库来交互。这时候，MSVC的ABI就是绕不过去的一个问题。可以参考 Rustup 的官方文档对Windows平台的描述，rust-lang-nursery/rustup.rs。 Windows平台上有两套ABI，一个是MSVC，一个是MinGW。所以你其实有两个选择，要么安装 msvc，然后
rustup install stable-x86_64-pc-windows-msvc
要么安装 MinGW，然后
rustup install stable-x86_64-pc-windows-gnu
在 Rustup 的文档上有这么一句话 By default rustup on Windows configures Rust to target the 32-bit MSVC ABI, that is the i686-pc-windows-msvc target triple. 所以，默认安装的话，你需要安装 msvc。

‘肆’ 我想玩rust但是不知道怎么下载

先下个steam平台
然后再平台上购买这个游戏
就可以下载下来玩了
因为这个游戏不是免费的
而且还没有破解，只能用这种方式玩
不过最好还是下个玲珑国际网游加速器
因为延迟也高，只有这个加速器能降低延迟

———————————————分割线——————————————————
满意请采纳(⊙o⊙)，以上是软硬谦施团队为你带来的回答。
如果有什么不懂的可以追问，以后有什么问题可以向我提问或者向我的团队提问。(*^__^*) 嘻嘻……

‘伍’ Rust语言的最新版本说明

Mozilla在2014年10月宣布发布Rust编译器和工具的0.12版。
0.12版有1900多项变化和bug修正，其中主要包括：重写了入门文档(现在叫Rust Guide);继续提高了包管理器Cargo等。
在2015年1月，发布了Rust-1.0.0-alpha版本。
2015年5月15日，Rust编程语言核心团队正式宣布发布Rust 1.0版本。
2015年6月25日，Rust发布了1.1版本。同时发布1.2测试版本 编译速度在1.1版本的基础上再提升30% 并行编译又能用了，默认未开启，如果开启，还能提升33%的编译速度（数据来自4核编译rustc） Cargo性能提升（编译Servo时启动速度提升10倍），可在多个package之间共享依赖包缓存 初步支持MSVC(Microsoft Visual C)，以后Windows环境中不需要MinGW/MySYS/GCC了 Rust 1.2 稳定版 将在六周之后发布，届时还将一并发布 1.3 测试版

‘陆’ 求编程电子书下载

Rust|教您玩转rust编程视频教程|电子书 ，免费下载

链接: https://pan..com/s/1BarkCHynpQkGjmumTV69yw

Rust是一门系统编程语言[1]，专注于安全[2]，尤其是并发安全，支持函数式和命令式以及泛型等编程范式的多范式语言。Rust在语法上和C++类似[3]，但是设计者想要在保证性能的同时提供更好的内存安全。 Rust最初是由Mozilla研究院的Graydon Hoare设计创造，然后在Dave Herman, Brendan Eich以及很多其他人的贡献下逐步完善的。[4]Rust的设计者们通过在研发Servo网站浏览器布局引擎过程中积累的经验优化了Rust语言和Rust编译器。

‘柒’ 想学编程不知道从哪里开始

Rust|教您玩转rust编程视频教程|电子书 ，免费下载

链接: https://pan..com/s/1BarkCHynpQkGjmumTV69yw

Rust是一门系统编程语言[1]，专注于安全[2]，尤其是并发安全，支持函数式和命令式以及泛型等编程范式的多范式语言。Rust在语法上和C++类似[3]，但是设计者想要在保证性能的同时提供更好的内存安全。 Rust最初是由Mozilla研究院的Graydon Hoare设计创造，然后在Dave Herman, Brendan Eich以及很多其他人的贡献下逐步完善的。[4]Rust的设计者们通过在研发Servo网站浏览器布局引擎过程中积累的经验优化了Rust语言和Rust编译器。

‘捌’ windows 7 下Rust 入门 Helloworld 怎么编写

方法/步骤
1、首先要在 电脑上安装 rust 语言，具体可参考
0windows7怎么安装 rust
2、打开一个编辑器，我用的是 Notepad ++ ，其他也可以，建议初学 最好用 文本编辑器，不要用什么IDE
3、输入代码：
// This is a comment, and will be ignored by the compiler
// 本行为注释，会被编译器忽略
// This is the main function
// 这是主函数
fn main() {

println!("Hello World!");
}
windows 7 下Rust 入门 Helloworld 怎么编写
4、输入无误后，保存为 "hello.rs", 注意文件后缀是 .rs
windows 7 下Rust 入门 Helloworld 怎么编写
5、打开一个 COMMAND, 转到 文件保存目录，输入 rustc hello.rs,回车。
windows 7 下Rust 入门 Helloworld 怎么编写
6、如果源代码没有写错的话，就会生成 hello.exe 文件
windows 7 下Rust 入门 Helloworld 怎么编写
7、验证结果 ，在COMMAND 中 直接 输入 hello.exe
如果 显示 hello world，表示编写成功
windows 7 下Rust 入门 Helloworld 怎么编写
8、rust 编程还是比较简单容易上手的。

‘玖’ 如何在msys2中安装rust语言编程环境

dll代码：#includeextern"C"void_declspec(dllexport)Msg(){MessageBox(NULL,"helloworld!","demo",MB_OK);}编译完成后把dll命名为fuck.dll,放到c盘下。调用dll的exe的代码：#includeintmain(){HMODULEhdll=LoadLibrary("c:\\fuck.dll");//加载dllif(hdll!=NULL){FARPROCproc=GetProcAddress(hdll,"Msg");if(proc!=NULL){//proc();_asmcallproc}}return0;}

‘拾’ java和Rust在实现多线程编程时的异同

Java的实现
打开Follower.java里的这个函数

这里的Follower.this.invitations就是我们的消息队列，定义是：private LinkedList<Invitation> invitations;LinkedList不是线性安全的集合，需要我们加同步。具体的同步方法就是函数里写的，通过Java常见的用wait，notify和notifyall给对象加锁。
处理并发有wait、notify和notiyall，有兴趣的朋友可以去这里了解一下：http://www.importnew.com/16453.html。Follower就是一个等待leader发送invitation，处理并返回结果的过程。
Leader.java
这么一段代码：

里面就是Leader发送邀请inv，并等待follower返回结果的大概逻辑，通过对消息体加锁，是Java传统的实现多线程并发的方式。还有消费者的消息队列也会加锁，在Java里，有个对象叫LinkedBlockingQueue，是不用加锁就可以put和take的，但在例子里，我们选用了更简单的LinkedList，也是为了表现一下加锁的逻辑。
Rust的实现
Leader的结构为：

Follower的结构为：

对于其他语言转过来的同学，这里的Vec，i32，bool都很好理解，不过里面出现的Arc和Mutex，Sender，Receiver就是新东西了，上面这4个都是Rust标准库的东西，也是这次分享要介绍的重点对象，是这4个东西共同实现了消息的生产，传递和消费。
下面简单介绍一下分别是做什么用的：
Arc<T>实现了sync接口。Sync接口是做什么呢？权威资料是这么说的：当一个类型T实现了Sync，它向编译器表明这个类型在多线程并发时没有导致内存不安全的可能性。
如果看不懂不要紧，我们先看看实际中是怎么用的：

在这个例子里，我们关注这几句：
let data = Arc::new(Mutex::new(vec![1u32, 2, 3]));
let data = data.clone();
let mut data = data.lock().unwrap();
下面分别解释一下是做什么的：
简单的说Arc::new表明了这是通过clone()方法来使用的，每clone，都会给该对象原子计数+1，通过引用计数的方法来保证对象只要还被其中任何一个线程引用就不会被释放掉，从而保证了前面说的：这个类型在多线程并发时没有导致内存不安全的可能性。
如果我们不定义为Arc<>就传到其他线程使用，编译器会报：
error: capture of moved value: `data`
data[i] += 1;
我们可以记住clone()就是Arc的用法。
接下来我们看Mutex：
Mutex实现了send接口。同样，在权威资料里是这么描述的：这个类型的所有权可以在线程间安全的转移
那我们又是怎么用Mutex的呢？就是用lock().unwrap()。lock()的作用是获取对象，如果当前有其他线程正在使用Mutex<T>里面的T对象时，本线程就会阻塞，从而保证同时只有一个线程来访问对象，mutex也另外提供了try_lock()的方法，是不阻塞的，只要其他线程被占用，就返回err，通常Arc和Mutex都是一起使用的。
回到我最原始的题目，Mutex和Arc实现了对象本身的线程共享，但是在线程间如何传递这个对象呢？就是靠channel，channel通常是这么定义的let (tx, rx) = mpsc::channel();它会返回两个对象tx和rx，就是之前我提到的sender和receiver。
在我的Rust实现里，关键的语句是以下几个：
let leaders = (0..leader_cnt).map(|i|
Arc::new(Mutex::new(Leader::new(i,dance_types.len() as i32)))
).collect::<Vec<_>>();
这一句是new一堆leader出来，Arc和Mutex表明leader是可以多线程共享和访问的。
同样Follower也是：
let followers = (0..follower_cnt).map(|i|
Arc::new(Mutex::new(Follower::new(i,dance_types.len() as i32,leader_cnt)))
).collect::<Vec<_>>();
接下来这几句就有点不好理解了。

这里定义了一堆的sender和receiver，其中把他们都作为leader和follower的成员变量存起来。大概意思就是每一个leader都通过sender列表可以发送invitation给所有follower，同时又有单个receiver来接受所有follower发给自己的处理结果inviresult。
同样follower也是这么做。这样在之后每一个follower和leader作为一个线程跑起来之后，都能在相互之间建立了一条通信的通道。
这个是和Java实现多线程并发最大的不同之处！Java是通过给对象加锁，Rust是通过channel转移对象的所有权，在代码里，leader发送inv给folloer是下面这一句
match self.senders[*follower_id as usize].lock().unwrap().send(inv){，其中的lock().unwrap()是获得该leader对该follower的发送通道的所有权，send(inv)就是转移具体的发送对象invitation所有权了。
这个转移按照我的理解，应该是内存拷贝。就是在follower接收的时候，let inv = match self.receiver.recv() { ，原来leader里面的inv在send之后已经是不可访问了，如果你之后再次访问了inv，会报use of moved value错误，而follower里面的inv则是在follower的栈里新生成的对象，所以，在Java里面我只定义了invitation对象，但是在Rust里面，我要再定义一个InviResult，因为我即使在follower线程里面填了result字段，leader线程也不能继续访问inv了。所以需要依靠follower再次发送一个invresult给leader，所以整个Rust程序大概就是这么一个思路。
实践总结
之前我测试比较Java和Rust实现的性能时，由于没有把调试信息去掉，导致Java比Rust慢很多，特别是那些调试信息都是调用String.format，这是比几个string相加慢上10倍的方法，两者都去掉调试信息后，leader和follower都会2000的时候，在我低端外星人笔记本里，性能差别大概是2倍吧，没我想象中大，Rust的程序整个写下来比较费力，一方面是对ownership机制不熟，思维没有转变过来，另一方面Rust的确需要开发者分部分精力到语法细节上。
编者注：冯总也有一些其它的实践体会，请参见CSDN对冯耀明的专访，请戳这里。也可以查看他的个人博客里的总结。
下面摘录采访中关于Rust的内容过来：
首先Rust里面的ownership和lifetime概念真的很酷，就因为这个概念实现无内存泄露，野指针和安全并发。
其次，Rust的语法不简单，也是有不少坑的，据说Rust的潜在用户应该是现在的C和C++程序员，他们可能会觉得比较习惯，说不定还 觉得更简单。由于ownership机制，一些在其他语言能够跑通的程序在Rust下就要调整实现了，它会改变你写程序的思维方式。据说一些写Rust超 过半年的程序员已经爱上它了！
我对Rust感受较深的是下面几点：
初学者不熟悉ownership机制，会无数次编译失败。但一旦编译成功，那么程序只剩下逻辑错误了。同样，由于ownership机制，将来在项目里修改Rust代码将可能是痛苦的过程，因为原来编译通过的代码可能加入新功能就编译不过了，这是我的猜测。
Rust编译速度慢，不过据说最近每一个Rust新发布的版本编译速度都比之前的版本提高了30%。
Rust没有类，有的是结构体加方法，我喜欢这种简单的概念。
Rust没有类继承，只有接口，虽然接口可以提供默认的实现。这样一来，在大型项目里原来类继承来重用代码的效果是否就要用成员变量实例来完成呢？
Rust没有null，取而代之的是None和Option<T>，也因此，结构体在初始化的时候必须初始化所有字段。
Rust有我一直很想要的错误值返回机制，而不必通过抛异常或者需要每每定义包含结果和错误体实现。
Rust用send和sync两个接口来处理多线程并发，其中Arc<T>和Mutex<T>分别实现了这两个接口，简单易用。
Rust目前没有一个强大的IDE，支持断点调试，变量监控等。
它跟现在动态语言是两个截然不同的方向，它适合一些资深的程序员，我倒是觉得有必要有这么一本书，叫《从C++到Rust，你需要改善的20个编程 习惯》，能从实践上告诉开发者Rust里我们应该遵从什么样的编程习惯。Rust未来是否像C那样流行开来成为新一代的主流语言没有人能够知道，但它绝对 是值得你去了解和关注的语言。
进一步的思考：反转链表 - Java和Rust的不同实现
Rust的list应该怎么定义，譬如反转列表又是怎么做呢？
由于ownership的机制和不存在空指针的情况，很多在其他带GC的语言能够跑起来的程序在Rust下面就要换一种做法。最近试用Rust的基础数据结构时，更加加强了我的看法。下面以最原始的链表list为例。
在Java中，考虑最基本的链表定义
class ListNode {
int val;
ListNode next;

ListNode(int x) {
val = x;
}

@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append("[");
sb.append(val);
ListNode pNext = this.next;
while (pNext != null) {
sb.append(",");
sb.append(pNext.val);
pNext = pNext.next;
}
sb.append("]");
return String.format("%s", sb.toString());
}
}
如果我们要反转链表，可以这么做：
public ListNode reverseList(ListNode head) {
if (head == null) {
return null;
}
ListNode pNext = head.next;
ListNode pPrevious = null;
while (head != null) {
pNext = head.next;
head.next = pPrevious;
pPrevious = head;
head = pNext;
}
return pPrevious;
}
那如果我们按照一般思维，在Rust里对应的实现就是这样子的：
struct ListNode{
id :i32,
next :Option<Box<ListNode>>
}
反转链表：
fn reverseList2(head :&mut Option<Box<ListNode>>) -> Option<Box<ListNode>> {
match *head{
None => None,
Some(head) => {
let mut head = Some(head);
let mut pNext = head.unwrap().next;
let mut pPrevious:Option<Box<ListNode>> = None;
while true {
match head {
None =>{break;}
_ =>{}
}
pNext = head.unwrap().next;
head.unwrap().next = pPrevious;
pPrevious = head;
head = pNext;
}
pPrevious
}
}
}
然后编译，报了以下错误：
=》match *head{

ERROR：cannot move out of borrowed content
=》 pNext = head.unwrap().next;
ERROR：cuse of moved value: `head`

这些错误就是因为Rust的ownership机制，让我们无法像Java或者C++里保存临时变量，特别是在循环里。反复试过各种写法，都行不通。
最后，换成这么来做
链表定义：
use List::*;

enum List {
Cons1(i32, Box<List>),
Nil,
}

// Methods can be attached to an enum
impl List {
#[inline]
fn new() -> List {
Nil
}

#[inline]
fn prepend(self, elem: i32) -> List {
Cons1(elem, Box::new(self))
}

fn len(&self) -> i32 {
match *self {
Cons1(_, ref tail) => 1 + tail.len(),
Nil => 0
}
}

fn stringify(&self) -> String {
match *self {
Cons1(head, ref tail) => {
format!("{}, {}", head, tail.stringify())
},
Nil => {
format!("Nil")
},
}
}
}

fn reverseList(list:List, acc:List ) -> List{
match list{
Cons1(val,tail) => {
reverseList(*tail,acc.prepend(val))
}
Nil => acc
}
}

fn main() {
let mut head = List::new();
let mut i=0;
while i < 10 {
i+=1;
head = head.prepend(i);
}
println!("{:30}",head.stringify());
let result = List::new();
let result = reverseList(head,result);
<span style="white-space:pre"> </span>println!("{:30}",result.stringify());
}
从结果可以看到，链表已经实现反转了。所以在Rust下面，很多做法都要换一下。有人说这就是Rust函数式编程的思维。我但愿这种递归式的做法不会有溢出。