#include<bits/stdc++.h> using namespace std; int f(int* i) { static int x = 0; x++; printf("%d -1, *i= %d\n", x, *i++); printf("%d -2, *i= %d\n", x, *i++); return *i; } int main() { int x[3] = { 1,2,3 }; x[0] = f(x) + f(x) + x[x[0]]; printf("x[0]=%d\n", x[0]); }
输出是
1 -1, *i= 1
1 -2, *i= 2
2 -1, *i= 1
2 -2, *i= 2
x[0]=8
(这输出也太奇怪了吧局部变量x增加了,x[0]没有变,所以求值策略是什么?感觉要看汇编代码)
(后来知道这个++优先级更高。。。太蠢了)
实现trim,去掉列表的最后一个元素。相当于 vector<int>v;v.pop_back()
(define (my-trim lst ) (cond ((null? lst) ; if the list is empty 'error) ; error ((equal? (cdr lst) '()) '()) (else ; if the list is non-empty (cons (car lst) ; cons the first element in the list (my-trim (cdr lst) ))))) ; with the result of advancing the recursion
*I1=*I2 var *I1=&I2 let var *I1=&I2 in C
(照着I=E和*I=E的语义瞎写的。有没有人来告诉我ppt最后两行是错的,当时就应该问老师的QAQ)
一个用synchonized实现的哲学家问题,问会出现什么问题,怎么改进,我正好找到了源码博客[1],和里面的教学思路一致(国内的java并发实现真的找不到标准代码)。
public class Philosopher implements Runnable { // The forks on either side of this Philosopher private Object leftFork; private Object rightFork; //引用调用,指向同一个对象,所以可以锁住 public Philosopher(Object leftFork, Object rightFork) { this.leftFork = leftFork; this.rightFork = rightFork; } private void doAction(String action) throws InterruptedException { System.out.println( Thread.currentThread().getName() + " " + action); Thread.sleep(((int) (Math.random() * 100))); } @Override public void run() { try { while (true) { // thinking doAction(System.nanoTime() + ": Thinking"); synchronized (leftFork) { doAction( System.nanoTime() + ": Picked up left fork"); synchronized (rightFork) { // eating doAction( System.nanoTime() + ": Picked up right fork - eating"); doAction( System.nanoTime() + ": Put down right fork"); } // Back to thinking doAction( System.nanoTime() + ": Put down left fork. Back to thinking"); } } } catch (InterruptedException e) { Thread.currentThread().interrupt(); return; } } public static void main(String[] args) throws Exception { final Philosopher[] philosophers = new Philosopher[5]; Object[] forks = new Object[philosophers.length]; for (int i = 0; i < forks.length; i++) { forks[i] = new Object(); } for (int i = 0; i < philosophers.length; i++) { Object leftFork = forks[i]; Object rightFork = forks[(i + 1) % forks.length]; if (i == philosophers.length - 1) { // The last philosopher picks up the right fork first philosophers[i] = new Philosopher(rightFork, leftFork); } else { philosophers[i] = new Philosopher(leftFork, rightFork); } Thread t = new Thread(philosophers[i], "Philosopher " + (i + 1)); t.start(); } } } class DiningPhilosophers { }
应该就是这里改的
类似作业里的题 大概长这样,但是里面还试图对内部类进行多态(定义了内部类,private内部类变量,内部类extend父类的内部类,子类通过set内部类实例到父类里)。个人理解内部类无法多态。类似这种
public class Foo { public void method1() { System.out.println("foo 1"); } public void method2() { System.out.println("foo 2"); } public String toString() { return "foo"; } } public class Baz extends Foo { public void method1() { System.out.println("baz 1"); } public String toString() { return "baz"; } } public class Mumble extends Baz { public void method2() { System.out.println("mumble 2"); } } public static void main(String[] args){ Foo[] pity = {new Baz(), new Bar(), new Mumble(), new Foo()}; for (int i = 0; i < pity.length;i++) { System.out.println(pity[i]); pity[i].method1(); pity[i].method2(); System.out.println(); } }
method | foo | bar | Mumble | baz |
---|---|---|---|---|
method1 | foo 1 | baz 1 | ||
method2 | foo 2 | bar 2 | numble 2 | |
toString | foo | baz |
近年考试比较简单,同学也是这么觉得。课程大作业可以没有代码实现,总之还是算能水过的核心课之一。
但是要真的掌握,内容太多了,每一章都能作为一节课。
作用域、闭包、堆栈帧、参数传递、prolog、语法、lambda演算都没考(基本也不是重点,但基础不好的我看了好久)。
我今天复习的时候真的折磨。java并发的内容是真的多、又不懂java,又不懂并发。
The Dining Philosophers Problem in Java | Baeldung ↩︎