计算机网络 --- 网络编程-6ren

计算机网络 --- 网络编程

转载作者：知者更新时间：2024-03-13 01:04:00

1. 网络编程

1.1 什么是网络编程

网络编程 : 指网络上的主机,通过不同的进程,以编程的方式实现网络通信.
简单来说: 网络编程就是通过代码的方式来控制不同进程间能够进行数据交互.

1.2 发送端和接收端

发送端：数据的发送方进程，称为发送端。发送端主机即网络通信中的源主机。
接收端：数据的接收方进程，称为接收端。接收端主机即网络通信中的目的主机。
收发端：发送端和接收端两端，也简称为收发端

1.3 请求和响应

请求(Request) : 客户端给服务端发送的数据
响应(Response) : 服务端给客户端返回的数据

1.4 客户端和服务端

客户端 : 主动发送请求的一方
服务端 : 被动接受请求的一方

客户端和服务端的交互方式:

一问一答,客户端发送一个请求,服务端给一个响应
一问多答,客户端发送一个请求,服务端给多个响应
多问一答,客户端发送多个请求,服务端给一个响应
多问多答,客户端发送多个请求,服务器端多个响应

2. Socket 套接字

Socket套接字，是由系统提供用于网络通信的技术，是基于TCP/IP协议的网络通信的基本操作单元。基于Socket套接字的网络程序开发就是网络编程.

2.1 分类

流套接字 : 使用传输层 TCP 协议

TCP协议,(Transmission Control Protocol)
TCP的特点:

有连接
可靠传输
面向字节流
有接收缓冲区,也有发送缓冲区
大小不限
全双工

数据报接字 : 使用传输层 UDP 协议

UDP协议,(User Datagram Protocl)
UDP的特点:

无连接
不可靠传输
面向数据报
有接收缓冲区,无发送缓冲区
大小受限: 一次最多传输64k
全双工

3. UDP数据报套接字编程

3.1 DatagramSocket API

DatagramSocket 是UDP Socket, 用于发送和接收UDP数据报.

构造方法

方法签名	方法说明
DatagramSocket()	创建一个UDP数据报套接字的Socket，绑定到本机任意一个随机端口（一般用于客户端）
DatagramSocket(int port)	创建一个UDP数据报套接字的Socket，绑定到本机指定的端口（一般用于服务端）

方法

方法签名	方法说明
void receive(DatagramPacket p)	从此套接字接收数据报（如果没有接收到数据报，该方法会阻塞等待）
void send(DatagramPacket p)	从此套接字发送数据报包（不会阻塞等待，直接发送）
void close()	关闭此数据报套接字

3.2 DatagramPacket API

DatagramPacket是UDP Socket发送和接收的数据报.

构造方法

方法签名	方法说明
DatagramPacket(byte[] buf, int length)	构造一个DatagramPacket以用来接收数据报，接收的数据保存在字节数组（第一个参数buf）中，接收指定长度（第二个参数length）
DatagramPacket(byte[] buf, int offset, int length,SocketAddress address)	构造一个DatagramPacket以用来发送数据报，发送的数据为字节数组（第一个参数buf）中，从0到指定长度（第二个参数length）。address指定目的主机的IP和端口号

方法

方法签名	方法说明
InetAddress getAddress()	从接收的数据报中，获取发送端主机IP地址；或从发送的数据报中，获取接收端主机IP地址
int getPort()	从接收的数据报中，获取发送端主机的端口号；或从发送的数据报中，获取接收端主机端口号
byte[] getData()	获取数据报中的数据

注: 构造UDP发送的数据报时，需要传入 SocketAddress ，该对象可以使用 InetSocketAddress 来创建。
InetSocketAddress的构造方法

方法签名	方法说明
InetSocketAddress(InetAddress addr, int port)	创建一个Socket地址，包含IP地址和端口号

3.3 基本使用方法:

服务端:

创建一个 DatagramSocket 对象,创建的同时关联一个端口号
读取请求并解析
根据请求计算响应
把响应写回到客户端
打印日志

客户端

创建一个 DatagramSocket 对象,创建的同时指定服务器的ip和端口号
读取输入的数据
构造请求并发送给服务器
从服务器读取响应
把数据显示给用户

使用示例: 一发一收

代码示例: UdpServer

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;

public class UdpEchoServer {
    private DatagramSocket socket = null;

    public UdpEchoServer(int port) throws SocketException {
        this.socket = new DatagramSocket(port);
    }

    public void start() throws IOException {
        System.out.println("服务器启动!");
        while (true) {
            // 1. 读取请求 并 解析
            DatagramPacket requestPacket = new DatagramPacket(new byte[4096],4096);
            socket.receive(requestPacket);
            String request = new String(requestPacket.getData(),0, requestPacket.getLength());
            // 2. 根据请求计算响应
            String response = process(request);
            // 3. 把响应写回到客户端
            DatagramPacket responsePacket = new DatagramPacket(response.getBytes(),response.getBytes().length,
                                                                requestPacket.getSocketAddress());
            socket.send(responsePacket);
            // 4. 打印日志
            String log = String.format("[%s:%d] req: %s; resp: %s",requestPacket.getAddress().toString(),
                                                                requestPacket.getPort(),request,response);
            System.out.println(log);
        }
    }

    private String process(String request) {
        return request;
    }

    public static void main(String[] args) throws IOException {
        UdpEchoServer server = new UdpEchoServer(9090);
        server.start();
    }
}

代码示例: UdpClient

import java.io.IOException;
import java.net.*;
import java.util.Scanner;

public class UdpEchoClient {
    private DatagramSocket socket = null;
    private String serverIp;
    private int serverPort;

    public UdpEchoClient(String serverIp,int serverPort) throws SocketException {
        this.serverIp = serverIp;
        this.serverPort = serverPort;
        this.socket = new DatagramSocket();
    }

    public void start() throws IOException {
        while (true) {
            // 1. 读取输入数据
            System.out.print("->");
            Scanner sc = new Scanner(System.in);
            String request = sc.next();
            if(request.equals("exit")){
                System.out.println("exit");
                break;
            }

            // 2. 构造请求 并 发送给服务器
            DatagramPacket requestPacket = new DatagramPacket(request.getBytes(),0,request.getBytes().length,
                                                        InetAddress.getByName(serverIp),serverPort);
            socket.send(requestPacket);

            // 3. 读取服务器的响应 并 解析
            DatagramPacket responsePacket = new DatagramPacket(new byte[4096],4096);
            socket.receive(responsePacket);
            String response = new String(responsePacket.getData(),0, responsePacket.getLength());

            // 4.显式给用户
            String log = String.format("req: %s; resp: %s",request,response);
            System.out.println(log);
        }
    }

    public static void main(String[] args) throws IOException {
        UdpEchoClient client = new UdpEchoClient("127.0.0.1",9090);
        client.start();
    }
}

运行结果:

使用示例: 翻译程序

客户端输入需要查找的英文的请求
客户端返回对应的英文翻译的响应
代码示例: UdpServer

package Translation;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;
import java.util.HashMap;
import java.util.Map;

public class UdpTranslateServer {
    private DatagramSocket socket = null;
    private Map<String,String> map = new HashMap<>();

    public UdpTranslateServer(int port) throws SocketException {
        this.socket = new DatagramSocket(port);
        map.put("translate","翻译");
        map.put("china","中国");
        map.put("hello","你好");
    }

    public void start() throws IOException {
        System.out.println("服务器启动!");
        while (true) {
            // 1. 读取请求并解析
            DatagramPacket requestPacket = new DatagramPacket(new byte[4096],4096);
            socket.receive(requestPacket);
            String request = new String(requestPacket.getData(),0, requestPacket.getLength());
            // 2. 根据请求计算响应
            String response = process(request);
            // 3. 把响应写回给客户端
            DatagramPacket responsePacket = new DatagramPacket(response.getBytes(),response.getBytes().length,
                                                                requestPacket.getSocketAddress());
            socket.send(responsePacket);
            // 4. 打印日志
            String log = String.format("[%s:%d] req: %s; resp: %s",requestPacket.getAddress().toString(),
                                        requestPacket.getPort(),request,response);
            System.out.println(log);
        }
    }

    private String process(String request) {
        return map.getOrDefault(request,"查无此单词");
    }

    public static void main(String[] args) throws IOException {
        UdpTranslateServer server = new UdpTranslateServer(9090);
        server.start();
    }
}

代码示例: UDPClient

package Translation;

import java.io.IOException;
import java.net.*;
import java.util.Scanner;

public class UdpTranslateClient {
    private DatagramSocket socket = null;
    private String serverIp;
    private int serverPort;

    public UdpTranslateClient (String serverIp,int serverPort) throws SocketException {
        this.serverIp = serverIp;
        this.serverPort = serverPort;
        socket = new DatagramSocket();
    }

    public void start() throws IOException {
        while (true) {
            System.out.print("->");
            Scanner sc = new Scanner(System.in);
            // 1. 根据用户的输入 构造请求
            String request = sc.next();
            if(request.equals("exit")){
                System.out.println("exit!");
                return;
            }
            // 2. 发送请求给服务器
            DatagramPacket requestPacket = new DatagramPacket(request.getBytes(),request.getBytes().length,
                                                    InetAddress.getByName(serverIp),serverPort);
            socket.send(requestPacket);
            // 3. 读取服务器的响应
            DatagramPacket responsePacket = new DatagramPacket(new byte[4096],4096);
            socket.receive(responsePacket);
            String response = new String(responsePacket.getData(),0, responsePacket.getLength());
            System.out.println(response);
            // 4. 解析响应并显式
            String log = String.format("req: %s; resp: %s",request,response);
            System.out.println(log);
        }
    }

    public static void main(String[] args) throws IOException {
        UdpTranslateClient client = new UdpTranslateClient("127.0.0.1",9090);
        client.start();
    }
}

运行结果:

4. TCP流套接字编程

4.1 ServerSocket API

构造方法

方法签名	方法说明
ServerSocket(int port)	创建一个服务端流套接字Socket，并绑定到指定端口

方法

方法签名	方法说明
Socket accept()	开始监听指定端口（创建时绑定的端口），有客户端连接后，返回一个服务端Socket对象，并基于该Socket建立与客户端的连接，否则阻塞等待
void close()	关闭此套接字

4.2 Socket API

构造方法

方法签名	方法说明
Socket(String host, int port)	创建一个客户端流套接字Socket，并与对应IP的主机上，对应端口的进程建立连接

方法

方法签名	方法说明
InetAddress getInetAddress()	返回套接字所连接的地址
InputStream getInputStream()	返回此套接字的输入流
OutputStream getOutputStream()	返回此套接字的输出流

4.3 基本使用方法

服务器

创建ServerSocket 关联上一个端口号

调用 ServerSocket 的 accept 方法
目的是建立连接
会返回一个 Socket 实例,称为 clientSocket
使用 clientSocket 的 getInputStream 和 getOutputStream 得到字节流对象,进行读写和写入
读取请求并解析
根据请求计算响应
把响应写回客户端
打印日志
当客户端断开连接之后,服务器就应该要及时的关闭 clientSocket. (防止出现文件泄露的情况)

客户端

创建一个 Socket 对象.创建的同时指定服务器的 ip 和端口

客户端就可以通过 Socket 对象的 getInputStream 和 getOutputStream 来和服务器进行通信
从键盘上,读取用户输入的内容
把这个读取的内容构造成请求,发送给服务端
从服务器读取响应并解析
把结构显示到界面上

使用示例1: 一发一收

这里的是普通版本不能处理多个客户端

代码示例: TCPClient

package TCP;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.Socket;
import java.util.Scanner;

public class TcpEchoClient {
    private Socket socket = null;
    private String serverIp;
    private int serverPort;

    public TcpEchoClient(String serverIp,int serverPort) throws IOException {
        this.serverIp = serverIp;
        this.serverPort = serverPort;
        // 让 socket 创建的同时,就和服务器尝试建立连接
        this.socket = new Socket(serverIp,serverPort);
    }

    public void start() {
        Scanner scanner = new Scanner(System.in);
        try(InputStream inputStream = socket.getInputStream();
            OutputStream outputStream = socket.getOutputStream()){
            while (true) {
                // 1. 从键盘上,读取用户输入的内容
                System.out.print("->");
                String request = scanner.next();
                if (request.equals("exit")){
                    break;
                }
                // 2. 把这个读取的内容构造成请求,发送给服务器
                PrintWriter printWriter = new PrintWriter(outputStream);
                printWriter.println(request);
                printWriter.flush();
                // 3. 从服务器读取响应并解析
                Scanner respScanner = new Scanner(inputStream);
                String response = respScanner.next();
                // 4. 把结果显示到界面上
                String log = String.format("req: %s; resp: %s",request,response);
                System.out.println(log);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) throws IOException {
        TcpEchoClient client = new TcpEchoClient("127.0.0.1",9090);
        client.start();
    }
}

代码示例: TCPServer

package TCP;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;

public class TcpEchoServer {
    private ServerSocket listenSocket = null;

    public TcpEchoServer(int port) throws IOException {
        listenSocket = new ServerSocket(port);
    }

    public void start() throws IOException {
        System.out.println("服务器启动!");
        while (true) {
            // 1. 建立连接
            Socket clientSocket = listenSocket.accept(); // 没有客户端来就会 阻塞等待
            processConnection(clientSocket);
        }
    }

    private void processConnection(Socket clientSocket) throws IOException {
        String log = String.format("[%s:%d] 客户端上线!",
                clientSocket.getInetAddress().toString(),clientSocket.getPort());
        System.out.println(log);
        try(InputStream inputStream = clientSocket.getInputStream();
            OutputStream outputStream = clientSocket.getOutputStream()) {
            while (true) {
                // 1. 读取请求并解析
                Scanner scanner = new Scanner(inputStream);
                if(!scanner.hasNext()){
                    log = String.format("[%s:%d] 客户端下线",clientSocket.getInetAddress().toString(),clientSocket.getPort());
                    System.out.println(log);
                    break;
                }
                String request = scanner.next();
                // 2. 根据请求计算响应
                String response = process(request);
                // 3. 把响应写回给客户端
                PrintWriter writer = new PrintWriter(outputStream);
                writer.println(response);
                writer.flush();

                log = String.format("[%s:%d] req: %s; resp: %s",clientSocket.getInetAddress().toString(),
                        clientSocket.getPort(),request,response);
                System.out.println(log);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            clientSocket.close();
        }
    }

    private String process(String request) {
        return request;
    }

    public static void main(String[] args) throws IOException {
        TcpEchoServer server =  new TcpEchoServer(9090);
        server.start();
    }
}

使用示例2: 多个客户端发一个服务器收

多线程版本,能处理多个客户端,但是需要频繁的创建销毁线程
代码示例 TCPServer (客户端一致)

package TCPThread;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;

public class TcpThreadEchoServer {
    private ServerSocket listenSocket = null;

    public TcpThreadEchoServer(int port) throws IOException {
        listenSocket = new ServerSocket(port);
    }

    public void start() throws IOException {
        System.out.println("服务器启动!");
        while (true) {
            Socket clientSocket = listenSocket.accept();
            // 创建一个线程来给这个客户提供服务
            Thread t = new Thread(){
                @Override
                public void run() {
                    try {
                        processConnection(clientSocket);
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            };
            t.start();
        }
    }
    public void processConnection(Socket clientSocket) throws IOException {
        // 1. 打印日志
        String log = String.format("[%s,%d] 客户端上线",clientSocket.getInetAddress().toString(),clientSocket.getPort());
        System.out.println(log);
        try (InputStream inputStream = clientSocket.getInputStream();
             OutputStream outputStream = clientSocket.getOutputStream()){
            while (true) {
                // 1. 读取 请求 并 解析
                Scanner sc = new Scanner(inputStream);
                if(!sc.hasNext()){
                    log = String.format("[%s,%d] 客户端下线",clientSocket.getInetAddress().toString(),clientSocket.getPort());
                    System.out.println(log);
                    break;
                }
                String request = sc.next();
                // 2. 根据请求计算响应
                String response = process(request);
                // 3. 把响应写回客户端
                PrintWriter printWriter = new PrintWriter(outputStream);
                printWriter.println(response);
                printWriter.flush();
                // 4. 打印日志
                log = String.format("[%s:%d] req: %s; resp: %s",clientSocket.getInetAddress().toString(),
                        clientSocket.getPort(),request,response);
                System.out.println(log);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            clientSocket.close();
        }
    }

    public String process(String request){
        return request;
    }

    public static void main(String[] args) throws IOException {
        TcpThreadEchoServer server = new TcpThreadEchoServer(9090);
        server.start();
    }
}

使用示例3: 多个客户端发一个服务器收(优化版)

由于多线程版的创建销毁线程的开销太大,这里使用线程池的方法.

package TCPThread;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class TcpThreadPoolEchoServer {
    private ServerSocket listenSocket = null;

    public TcpThreadPoolEchoServer(int port) throws IOException {
        listenSocket = new ServerSocket(port);
    }

    public void start() throws IOException {
        System.out.println("服务器启动");
        ExecutorService executorService = Executors.newCachedThreadPool();
        while (true) {
            Socket clientSocket = listenSocket.accept();
            // 使用线程池 来 处理当前的 processConnextion
            executorService.submit(()-> {
                try {
                    processConnection(clientSocket);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            });
        }
    }
    public void processConnection(Socket clientSocket) throws IOException {
        // 1. 打印日志
        String log = String.format("[%s,%d] 客户端上线",clientSocket.getInetAddress().toString(),clientSocket.getPort());
        System.out.println(log);
        try (InputStream inputStream = clientSocket.getInputStream();
             OutputStream outputStream = clientSocket.getOutputStream()){
            while (true) {
                // 1. 读取 请求 并 解析
                Scanner sc = new Scanner(inputStream);
                if(!sc.hasNext()){
                    log = String.format("[%s,%d] 客户端下线",clientSocket.getInetAddress().toString(),clientSocket.getPort());
                    System.out.println(log);
                    break;
                }
                String request = sc.next();
                // 2. 根据请求计算响应
                String response = process(request);
                // 3. 把响应写回客户端
                PrintWriter printWriter = new PrintWriter(outputStream);
                printWriter.println(response);
                printWriter.flush();
                // 4. 打印日志
                log = String.format("[%s:%d] req: %s; resp: %s",clientSocket.getInetAddress().toString(),
                        clientSocket.getPort(),request,response);
                System.out.println(log);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            clientSocket.close();
        }
    }

    public String process(String request){
        return request;
    }

}

运行结果

使用示例4: 翻译程序

代码示例: TCPServer (这里的客户端还是跟前面一样)

package Translation;

import TCPThread.TcpThreadPoolEchoServer;

import java.io.IOException;
import java.util.HashMap;

// echo 和 translate 两个服务器之间,大多都是类似的
public class TcpTranslateServer extends TcpThreadPoolEchoServer {
    private HashMap<String,String> map = new HashMap<>();

    public TcpTranslateServer(int port) throws IOException {
        super(port);
        map.put("china","中国");
        map.put("hello","你好");
        map.put("translate","翻译");
    }

    @Override
    public String process(String request) {
        return map.getOrDefault(request,"查无此单词!");
    }

    public static void main(String[] args) throws IOException {
        TcpTranslateServer server = new TcpTranslateServer(9090);
        server.start();
    }
}

运行结果:

5. 网络计算器(自定义协议)

我们自定义协议
请求 : 字符串类型操作数1;操作数2;运算符
响应 : 字符串类型计算响应

服务端代码

package Calculator;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;

public class CalcServer {
    private DatagramSocket socket = null;

    public CalcServer(int port) throws SocketException {
        socket = new DatagramSocket(port);
    }

    public void start() throws IOException {
        System.out.println("服务器启动!");
        while (true){
            // 1. 读取请求并解析
            DatagramPacket requestPacket = new DatagramPacket(new byte[4096],4096);
            socket.receive(requestPacket);
            String request = new String(requestPacket.getData(),0,requestPacket.getLength());
            // 2. 跟据请求计算响应
            String response = process(request);
            // 3. 把响应写回给客户端
            DatagramPacket responsePacket = new DatagramPacket(response.getBytes(),response.getBytes().length,
                                                            requestPacket.getSocketAddress());
            socket.send(responsePacket);
            // 4. 打印日志
            String log = String.format("[%s:%d] req: %s; resp: %s",requestPacket.getAddress().toString(),
                                    requestPacket.getPort(),request,response);
            System.out.println(log);
        }
    }

    private String process(String request) {
        // 分离
        String[] str = request.split(";");
        if(str.length != 3) return "[请求的格式出错!]";
        int num1 = Integer.parseInt(str[0]);
        int num2 = Integer.parseInt(str[1]);
        if(str[2].equals("+")){
            return num1+num2+"";
        }else if(str[2].equals("-")){
            return num1-num2+"";
        }else if(str[2].equals("*")){
            return (num1 * num2)+"";
        }else if(str[2].equals("/")){
            return (num1 / num2)+"";
        }
        return "[请求格式出错!操作符不支持!]";
    }

    public static void main(String[] args) throws IOException {
        CalcServer server = new CalcServer(9090);
        server.start();
    }
}

客户端代码

package Calculator;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
import java.util.Scanner;

public class CalcClient {
    private String serverIp;
    private int serverPort;
    private DatagramSocket socket = null;

    public CalcClient(String serverIp,int serverPort) throws SocketException {
        this.serverIp = serverIp;
        this.serverPort = serverPort;
        socket = new DatagramSocket();
    }

    public void start() throws IOException {
        Scanner sc = new Scanner(System.in);
        while (true) {
            // 1. 用户输入的请求
            System.out.print("请输入操作数1: ");
            int num1 = sc.nextInt();
            System.out.print("请输入操作数2: ");
            int num2 = sc.nextInt();
            System.out.print("请输入运算符: ");
            String operator = sc.next();
            String request = num1+";"+num2+";"+operator;
            // 2. 构造请求,并发给服务器
            DatagramPacket requestPacket = new DatagramPacket(request.getBytes(),0,request.getBytes().length,
                    InetAddress.getByName(serverIp),serverPort);
            socket.send(requestPacket);
            // 3. 从服务器中读取响应
            DatagramPacket responsePacket = new DatagramPacket(new byte[4096],4096);
            socket.receive(responsePacket);
            String response = new String(responsePacket.getData(),0,responsePacket.getLength());

            // 4. 将结果显示到屏幕上
            String log = String.format("req: %s; resp: %s",request,response);
            System.out.println(log);
        }
    }

    public static void main(String[] args) throws IOException {
        CalcClient client = new CalcClient("127.0.0.1",9090);
        client.start();
    }
}

运行结果:

文章推荐：贪心算法 --- LeetCode刷题

文章推荐：前端总复习——html篇

文章推荐： Servlet API

文章推荐： MySQL 数据备份与恢复

timer - UNIX 编程。 struct timeval 如何打印它(C 编程)
我正在尝试打印 timeval 类型的值。实际上我可以打印它，但我收到以下警告: 该行有多个标记格式“%ld”需要“long int”类型，但参数 2 的类型为“struct timeval” 程序
c - Unix 编程... fork() & execv() 帮助... C 编程
我正在编写自己的 unix 终端，但在执行命令时遇到问题: 首先，我获取用户输入并将其存储到缓冲区中，然后我将单词分开并将它们存储到我的 argv[] 数组中。IE命令是“firefox”以启动存储在
CUDA 编程
我是 CUDA 的新手。我有一个关于一个简单程序的问题，希望有人能注意到我的错误。 __global__ void ADD(float* A, float* B, float* C) { con
CGI 编程
我有一个关于 C 语言 CGI 编程的一般性问题。我使用嵌入式 Web 服务器来处理 Web 界面。为此，我在服务器中存储了一个 HTML 文件。在此 HTML 文件中包含 JavaScript 和
编程，不止有代码，还有艺术
**摘要：**在代码的世界中，是存在很多艺术般的写法，这可能也是部分程序员追求编程这项事业的内在动力。本文分享自华为云社区《【云驻共创】用4种代码中的艺术试图唤回你对编程的兴趣》，作者： break
R 编程 - 在它被调用的环境中创建变量
我有一个函数，它的任务是在父对象中创建一个变量。我想要的是让函数在调用它的级别创建变量。 createVariable testFunc() [1] "test" > testFunc2() [1]
C 编程 - 关于花括号的困惑
以下代码用于将多个连续的空格替换为1个空格。虽然我设法做到了，但我对花括号的使用感到困惑。这个实际上运行良好: #include #include int main() { int ch, la
C 编程 - 编写可自行编译的文本文件
我正在尝试将文件写入磁盘，然后自动重新编译。不幸的是，某事似乎不起作用，我收到一条我还不明白的错误消息(我是 C 初学者 :-)。如果我手动编译生成的 hello.c，一切正常吗？! #include
C 编程 - 传递指向数组的指针
如何将指针值传递给结构数组；例如，在 txt 上我有这个: John Doe;xxxx@hotmail.com;214425532; 我的代码: typedef struct Person{
C# SNMP 编程
我尝试编写一些代码来检索 objectID，结果是 2B-06-01-04-01-82-31-01-03-01-01 . 这个值不正确吗？ // Send a SysObjectId SNMP req
R 编程 - 对具有共同值的行的元素求和
您好，提前感谢您的帮助， (请注意评论部分以获得更多见解:即，以下示例中的成本列已添加到此问题中；西蒙提供了一个很好的答案，但成本列本身并未出现在他的数据响应中，尽管他提供的功能与成本列一起使用) 我
r - R中具有整数变量的非线性优化/编程
我想知道是否有人能够提出一些解决非线性优化问题的软件包的方法，而非线性优化问题可以为优化解决方案提供整数变量？问题是使具有相等约束的函数最小化，该函数受某些上下边界约束的约束。我已经在R中使用了'n
R 编程 - 向现有矩阵添加额外的列
我是 R 编程的初学者，正在尝试向具有 50 列的矩阵添加一个额外的列。这个新列将是该行中前 10 个值的平均值。 randomMatrix <- generateMatrix(1,5000,100,
C 编程 - 按位运算符并了解何时使用
我在《K&R II C 编程 ANSI C》一书中读到，“>>”和“0; nwords--) sum += *buf++; sum = (sum >>
Javascript - GUI 编程
当下拉列表的选择发生变化时，我想: 1) 通过 div 在整个网站上显示一些 GUI 阻止覆盖 2)然后处理一些代码 3) 然后隐藏叠加层。问题是，当我在事件监听器函数中编写此逻辑时，将执行 onC
Clojure "DSL"编程
我正在使用 Clojure 和 RESTEasy 设计 JAX-RS REST 服务器. 据我了解，用 Lisp 系列语言编写的应用程序比用“传统”命令式语言编写的应用程序更多地构建为“特定于领域的语
VBA 编程。如何将数据从用户窗体传输到工作表的特定行和列？
我目前正在研究一种替代出勤监控系统作为一项举措。目前，我设计的用户表单如下所示: Time Stamp Userform 它的工作原理如下: 员工将选择他/她将使用的时间戳类型:开始时间、超时、第一次
Java 编程 - 可除性和计数？
我是一名学生，试图自学编程，从在线资源和像您这样的人那里获得帮助。我在网上找到了一个练习来创建一个小程序来执行此操作: 编写一个程序，读取数字 a 和 b(长整型)并列出 a 和 b 之间有多少个数字
模数运算的 Shell 编程
我正在尝试编写一个 shell 程序，给定一个参数，打印程序的名称和参数中的每个奇数词(即，不是偶数词)。但是，我没有得到预期的结果。在跟踪我的程序时，我注意到，尽管奇数词(例如，第 5 个词，5 %
Java LED 编程
只是想知道是否有任何 Java API 可以让您控制台式机/笔记本电脑外壳上的 LED？或者，如果不可能，是否有可能？最佳答案如果你说的是前面的 LED 指示电源状态和 HDD 繁忙状态，恐怕没

知者

个人简介

我是一名优秀的程序员,十分优秀！

作者热门文章

滴滴打车优惠券免费领取

全站热门文章

首页

博学

6Ren·AI

商城