把void process(LinkedList *L)改为(LinkedList L)后该如何更改内容
时间: 2024-06-13 19:06:19 浏览: 1
根据提供的引用内容,将`void process(LinkedList *L)`改为`void process(LinkedList L)`后,需要将函数内部的所有`L->`改为`L.`。因为在前者中,L是一个指向LinkedList对象的指针,需要使用箭头运算符来访问对象的成员变量和成员函数;而在后者中,L是一个LinkedList对象,需要使用点运算符来访问对象的成员变量和成员函数。
例如,如果原来的代码是这样的:
```c++
void process(LinkedList *L) {
L->add(1);
L->remove(0);
}
```
那么修改后的代码应该是这样的:
```c++
void process(LinkedList L) {
L.add(1);
L.remove(0);
}
```
相关问题
List<Map<String, Object>> prrMapList = new LinkedList<>(); List<Map<String, Object>> ptrMapList = new LinkedList<>(); for (Record record : container) { if (record.getType().equalsIgnoreCase("PRR")) { Byte partFlg = (Byte) record.getData().getField("PART_FLG"); Map<String, Object> prrMap = new HashMap<>(); prrMap.put("lot","000000"); prrMap.put("product","STAR000000"); prrMap.put("process","test"); prrMap.put("test_time",new Date()); prrMap.put("wafer","000000"); prrMap.put("y_axis",record.getData().getField("Y_COORD")); prrMap.put("create_time",new Date()); prrMap.put("x_axis",record.getData().getField("X_COORD")); prrMap.put("user_name",userName); prrMap.put("soft_bin",record.getData().getField("SOFT_BIN")); prrMap.put("test_failed", partFlg == 0 ? 0 : 1); prrMap.put("hard_bin",record.getData().getField("HARD_BIN")); prrMapList.add(prrMap); } if (record.getType().equalsIgnoreCase("PTR")){ //Byte partFlg = (Byte) record.getData().getField("PART_FLG"); Map<String, Object> ptrMap = new HashMap<>(); ptrMap.put("product","STAR000000"); ptrMap.put("head_num",record.getData().getField("HEAD_NUM")); ptrMap.put("y_axis","");//需要找到来源 ptrMap.put("create_time",new Date()); ptrMap.put("x_axis","");//需要找到来源 ptrMap.put("user_name",userName); ptrMap.put("site_num",record.getData().getField("SITE_NUM")); //ptrMap.put("test_failed", partFlg == 0 ? 0 : 1); ptrMap.put("lot","000000"); ptrMap.put("result",record.getData().getField("RESULT")); ptrMap.put("test_time",new Date()); ptrMap.put("wafer","000000"); ptrMap.put("low_limit",record.getData().getField("LO_LIMIT")); ptrMap.put("high_limit",record.getData().getField("HI_LIMIT")); ptrMap.put("test_name",record.getData().getField("TEST_TXT")); ptrMap.put("test_number",record.getData().getField("TEST_NUM")); ptrMapList.add(ptrMap); } } 帮我用装饰者模式解偶
为了解耦,我们可以使用装饰者模式,将不同类型的记录处理逻辑抽象成一个接口,然后用不同的装饰者来实现该接口,最终将处理逻辑与原始代码解耦。
首先,我们创建一个 RecordProcessor 接口,用于处理记录:
```
public interface RecordProcessor {
void processRecord(Record record, List<Map<String, Object>> mapList, String userName);
}
```
然后,我们创建两个装饰者,分别用于处理 PRR 和 PTR 记录:
```
public class PrrRecordProcessor implements RecordProcessor {
@Override
public void processRecord(Record record, List<Map<String, Object>> mapList, String userName) {
Byte partFlg = (Byte) record.getData().getField("PART_FLG");
Map<String, Object> prrMap = new HashMap<>();
prrMap.put("lot","000000");
prrMap.put("product","STAR000000");
prrMap.put("process","test");
prrMap.put("test_time",new Date());
prrMap.put("wafer","000000");
prrMap.put("y_axis",record.getData().getField("Y_COORD"));
prrMap.put("create_time",new Date());
prrMap.put("x_axis",record.getData().getField("X_COORD"));
prrMap.put("user_name",userName);
prrMap.put("soft_bin",record.getData().getField("SOFT_BIN"));
prrMap.put("test_failed", partFlg == 0 ? 0 : 1);
prrMap.put("hard_bin",record.getData().getField("HARD_BIN"));
mapList.add(prrMap);
}
}
public class PtrRecordProcessor implements RecordProcessor {
@Override
public void processRecord(Record record, List<Map<String, Object>> mapList, String userName) {
Map<String, Object> ptrMap = new HashMap<>();
ptrMap.put("product","STAR000000");
ptrMap.put("head_num",record.getData().getField("HEAD_NUM"));
ptrMap.put("y_axis","");//需要找到来源
ptrMap.put("create_time",new Date());
ptrMap.put("x_axis","");//需要找到来源
ptrMap.put("user_name",userName);
ptrMap.put("site_num",record.getData().getField("SITE_NUM"));
//ptrMap.put("test_failed", partFlg == 0 ? 0 : 1);
ptrMap.put("lot","000000");
ptrMap.put("result",record.getData().getField("RESULT"));
ptrMap.put("test_time",new Date());
ptrMap.put("wafer","000000");
ptrMap.put("low_limit",record.getData().getField("LO_LIMIT"));
ptrMap.put("high_limit",record.getData().getField("HI_LIMIT"));
ptrMap.put("test_name",record.getData().getField("TEST_TXT"));
ptrMap.put("test_number",record.getData().getField("TEST_NUM"));
mapList.add(ptrMap);
}
}
```
最后,我们修改原始代码,将记录处理逻辑抽象成 RecordProcessor 接口,并使用装饰者来处理不同类型的记录:
```
List<Map<String, Object>> prrMapList = new LinkedList<>();
List<Map<String, Object>> ptrMapList = new LinkedList<>();
for (Record record : container) {
RecordProcessor processor;
if (record.getType().equalsIgnoreCase("PRR")) {
processor = new PrrRecordProcessor();
} else if (record.getType().equalsIgnoreCase("PTR")) {
processor = new PtrRecordProcessor();
} else {
continue;
}
processor.processRecord(record, prrMapList, userName);
}
```
(2)使用时间片轮转算法完成进程的调度 时间片轮转调度:具体做法是调度程序每次把 CPU 分配给当前最高优先级进程使用一个时间 片。当这个时间片结束时,强迫该进程让出处理器,进行下一轮优先级调度,直至就绪队列中所有 进程都运行完成为止。实现这种调度要使用一个间隔时钟。当一个进程开始运行时,就将时间片的 值置入间隔时钟内,当发生间隔时钟中断时,就表明该进程连续运行的时间已超过一个规定的时间 片。此时,中断处理程序就通知处理器调度进行处理器的切换工作。用java语言实现
以下是使用Java实现时间片轮转调度的示例代码:
```java
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Queue;
public class TimeSliceScheduler {
private Queue<Process> readyQueue; // 就绪队列
private ArrayList<Process> processList; // 进程列表
private int timeSlice; // 时间片大小
public TimeSliceScheduler(int timeSlice, ArrayList<Process> processList) {
this.timeSlice = timeSlice;
this.processList = processList;
readyQueue = new LinkedList<>();
}
public void start() {
int currentTime = 0;
while (!readyQueue.isEmpty() || !allProcessesFinished()) {
// 将到达当前时间的进程加入就绪队列
for (Process process : processList) {
if (process.getArrivalTime() == currentTime) {
readyQueue.offer(process);
}
}
if (!readyQueue.isEmpty()) {
Process currentProcess = readyQueue.poll();
currentProcess.execute(timeSlice);
if (currentProcess.isFinished()) {
System.out.println("Process " + currentProcess.getName() + " finished at time " + currentTime);
} else {
readyQueue.offer(currentProcess);
}
}
currentTime++;
}
}
private boolean allProcessesFinished() {
for (Process process : processList) {
if (!process.isFinished()) {
return false;
}
}
return true;
}
}
class Process {
private String name;
private int arrivalTime;
private int burstTime;
private int remainingTime;
public Process(String name, int arrivalTime, int burstTime) {
this.name = name;
this.arrivalTime = arrivalTime;
this.burstTime = burstTime;
remainingTime = burstTime;
}
public String getName() {
return name;
}
public int getArrivalTime() {
return arrivalTime;
}
public int getBurstTime() {
return burstTime;
}
public boolean isFinished() {
return remainingTime == 0;
}
public void execute(int timeSlice) {
if (remainingTime <= timeSlice) {
// 进程执行完毕
remainingTime = 0;
} else {
// 进程执行一段时间后还需继续执行
remainingTime -= timeSlice;
}
}
}
```
在上面的示例代码中,我们定义了一个 `Process` 类来表示进程,其中包括进程名称、到达时间、执行时间等信息。我们还定义了一个 `TimeSliceScheduler` 类来实现时间片轮转调度算法,其中包括就绪队列、进程列表和时间片大小等成员变量。
在 `start` 方法中,我们使用一个循环来模拟进程执行过程。每次循环,我们将到达当前时间的进程加入就绪队列,然后从就绪队列中取出一个进程执行一段时间,如果进程执行完毕,则输出进程完成信息,否则将进程重新加入就绪队列。
当所有进程都执行完毕后,循环结束。
相关推荐
![zip](https://img-home.csdnimg.cn/images/20210720083736.png)
![pdf](https://img-home.csdnimg.cn/images/20210720083512.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)