Sockets 套接字的Rust结构字段可变

我试着从Rust开始，试着把一些片段放在一起，创建一个“服务器”实例，其中包含一个“客户机”向量，每个客户机都有一个套接字

我知道在Rust中，套接字或TcpStream需要是可变的，并且我需要借用引用，以便在我的主循环中保留客户机实例化后的范围

但我面临的问题是，我的TcpStream字段在客户端结构中可能不可变。所以我不确定我的方法是否正确，但我尝试使用life参数life参数来解决这个问题

有人能帮我解决这个问题吗，或者告诉我解决这个问题/解决方案的正确方法吗

谢谢

use std::net::*;
use std::io::Write;
use std::thread;
use std::time::Duration;

struct Client<'a> {
    socket: &'a mut TcpStream,
    addr: SocketAddr
}

struct Server {
    clients: Vec<Box<Client>>
}

impl Server {
    pub fn new() -> Server {
        Server{clients: Vec::new()}
    }

    fn write(&self, stream: &mut TcpStream) {
        let mut counter: u32 = 0;
        counter += 1;
        stream.write(counter.to_string().as_bytes()).unwrap();
        thread::sleep(Duration::from_secs(1));
    }

    fn client_thread(&self, client: &mut Client) {
        self.write(&mut client.socket);
    }

    fn add_client(&self, socket: &mut TcpStream, addr: SocketAddr) {
        let mut client = Client {
            socket: socket,
            addr: addr
        };

        self.clients.push(Box::new(client));

        self.client_thread(&mut client);
    }

    pub fn server_loop(&self) {
        let listener = TcpListener::bind("127.0.0.1:5001").unwrap();

        loop {
            match listener.accept() {
                Ok((mut socket, addr)) => {
                    println!("new client: {:?}", addr);

                    thread::spawn(move || loop {
                        self.add_client(&mut socket, addr);
                    });
                },
                Err(e) => println!("couldn't get client: {:?}", e),
            }
        }
    }
}

fn main() {
    let mut server = Server::new();
    server.server_loop();
}

---

我现在能够解决整个问题：

use std::net::*;
use std::io::Write;
use std::thread;

struct Client {
    socket: TcpStream,
}

impl Client {
    pub fn write(&mut self) {
        let counter: u32 = 0;
        self.socket.write(counter.to_string().as_bytes()).unwrap();
    }
}

struct ClientThread {
    inner: Client,
}

impl ClientThread {
    pub fn client_loop(&mut self) {
        let client = &mut self.inner;

        client.write();
    }
}

struct Server {
    _clients: Vec<Box<Client>>,
}

impl Server {
    fn new() -> Server {
        Server { _clients: vec![] }
    }

    fn add_client(&mut self, s: TcpStream) {
        let client = Client { socket: s };

        println!("New client: {}", client.socket.peer_addr().unwrap());

        self._clients.push(Box::new(client));

        let mut client_thread = ClientThread { inner: client };

        thread::spawn(move || loop {
            client_thread.client_loop();
        });
    }

    pub fn server_loop(&mut self) {
        let listener = TcpListener::bind("127.0.0.1:5001").unwrap();

        loop {
            match listener.accept() {
                Ok((socket, _addr)) => {
                    self.add_client(socket);
                }
                Err(e) => println!("Couldn't get client: {}", e),
            }
        }
    }
}

fn main() {
    let mut server = Server::new();
    server.server_loop();
}

使用std:：net:：*；
使用std:：io:：Write；
使用std：：线程；
结构客户端{
插座：TcpStream，
}
impl客户端{
发布fn写入（&M自我）{
let计数器：u32=0；
self.socket.write（counter.to_string（）.as_bytes（））.unwrap（）；
}
}
结构客户端线程{
内部：客户，
}
impl客户端线程{
发布fn客户端循环（&mut self）{
让客户端=&mut self.inner；
client.write（）；
}
}
结构服务器{
_客户：Vec，
}
impl服务器{
fn new（）->Server{
服务器{u客户端：vec！[]}
}
fn添加\u客户端（多个自身，s:TcpStream）{
让client=client{socket:s}；
println！（“新客户端：{}”，client.socket.peer_addr（）.unwrap（））；
self._clients.push（Box:：new（client））；
让mut client_thread=ClientThread{inner:client}；
线程：：生成（移动| |循环{
client_thread.client_loop（）；
});
}
发布fn服务器\u循环（&mut self）{
让listener=TcpListener:：bind（“127.0.0.1:5001”）.unwrap（）；
环路{
匹配侦听器。接受（）{
正常（（套接字，地址））=>{
self.add_客户端（socket）；
}
Err（e）=>println！（“无法获取客户端：{}”，e），
}
}
}
}
fn main（）{
让mut server=server:：new（）；
server.server_loop（）；
}

请详细说明您的问题。一个好的代码通常包含从编译器中逐字复制的错误消息。例如：您在移动某个对象后获取对该对象的引用，您尝试将对局部变量的引用传递给线程，您可能希望在这些地方使用

&mut self

而不是

&self

，等等。。你读过吗？强烈推荐。我尝试使用生存期参数

Hi@E_net4解决此问题，很抱歉没有提供更好的详细信息，现在将添加错误消息。Hi@Shepmaster，非常感谢您对阅读的建议，我将立即阅读。你说的关于使用的话真的很有道理，我会努力改进。但在此期间，您能帮助我解决上述错误吗？使用包含客户机的Vec的结构时？不要使用
\uu
启动标识符，除非它们未使用。这不是C++，您必须避免成员变量和方法之间的名称冲突。
use std::net::*;
use std::io::Write;
use std::thread;

struct Client {
    socket: TcpStream
}

struct Server {
    clients: Vec<Box<Client>>
}

impl Server {
    fn new() -> Server {
        Server{clients: vec![]}
    }

    fn write(&mut self, stream: &mut TcpStream) {
        let mut counter: u32 = 0;
        stream.write(counter.to_string().as_bytes()).unwrap();
    }

    fn client_loop(&mut self, client: &mut Client) {
        loop {
            self.write(&mut client.socket);
        }
    }

    fn add_client(&mut self, s: TcpStream) {
        let mut client = Client{
            socket: s
        };

        self.clients.push(Box::new(client));

        println!("New client: {}", client.socket.peer_addr().unwrap());

        thread::spawn(move || {
            self.client_loop(&mut client);
        });
    }

    pub fn server_loop(&mut self) {
        let listener = TcpListener::bind("127.0.0.1:5001").unwrap();

        loop {
            match listener.accept() {
                Ok((socket, _addr)) => {
                    self.add_client(socket);
                },
                Err(e) => println!("Couldn't get client: {}", e),
            }
        }
    }
}

fn main() {
    let mut server = Server::new();
    server.server_loop();
}

  --> src/main.rs:38:9
   |
38 |         thread::spawn(move || {
   |         ^^^^^^^^^^^^^
   |
   = note: type must satisfy the static lifetime

use std::net::*;
use std::io::Write;
use std::thread;

struct Client {
    socket: TcpStream,
}

impl Client {
    pub fn write(&mut self) {
        let counter: u32 = 0;
        self.socket.write(counter.to_string().as_bytes()).unwrap();
    }
}

struct ClientThread {
    inner: Client,
}

impl ClientThread {
    pub fn client_loop(&mut self) {
        let client = &mut self.inner;

        client.write();
    }
}

struct Server {
    _clients: Vec<Box<Client>>,
}

impl Server {
    fn new() -> Server {
        Server { _clients: vec![] }
    }

    fn add_client(&mut self, s: TcpStream) {
        let client = Client { socket: s };

        println!("New client: {}", client.socket.peer_addr().unwrap());

        self._clients.push(Box::new(client));

        let mut client_thread = ClientThread { inner: client };

        thread::spawn(move || loop {
            client_thread.client_loop();
        });
    }

    pub fn server_loop(&mut self) {
        let listener = TcpListener::bind("127.0.0.1:5001").unwrap();

        loop {
            match listener.accept() {
                Ok((socket, _addr)) => {
                    self.add_client(socket);
                }
                Err(e) => println!("Couldn't get client: {}", e),
            }
        }
    }
}

fn main() {
    let mut server = Server::new();
    server.server_loop();
}