Yrh' Blog

Java Stream & Collectors

Fri, 19 Sep 2025 00:00:00 GMT

先偷张图

Stream

map

<R> stream<R> map(Function<? super T, ? extends R> mapper);

挖个坑：这里他这么定义是遵从了一个 “输入逆变、输出协变“的一个规则，等后面再补一篇

Stream.of("hello", "how", "are", "you")
  .map(String::length)
  .forEach(System.out::println);

flatMap

大概就是说把元素拍扁，然后把拍扁的元素重新组成Stream，然后把这些Stream串行合并成一条Stream

<R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper);

Stream.of("a-b-c-d", "1-2-3-4")
  .flatMap(e -> Arrays.stream(e.split("-")))
  .forEach(System.out::println);

limit

限制元素个数

distinct

去重，默认是根据元素的equals() 和 hashCode()来判断的

filter

给他一个条件函数传入参数返回true or false即可

Stream<T> filter(Predicate<? super T> predicate);

sorted

用法大差不差，实现Comparable接口就行

Stream<T> sorted();                           // 自然顺序
Stream<T> sorted(Comparator<? super T> comp); // 自定义比较器

collect

<R, A> R collect(Collector<? super T, A, R> collector);

这个要整理一下Collectors的api了，看下文吧

reduce

类似于FP的规约操作

Optional<T> reduce(BinaryOperator<T> accumulator);
T reduce(T identity, BinaryOperator<T> accumulator);
<U> U reduce(U identity,
             BiFunction<U, ? super T, U> accumulator,
             BinaryOperator<U> combiner);

Optional<Integer> sum = Stream.of(1, 2, 3, 4, 5)
  .reduce((a, b) -> a + b);

int sum = Stream.of(1, 2, 3, 4, 5)
  .reduce(0, (a, b) -> a + b);

int lengthSum = Stream.of("a", "bb", "ccc")
  .parallel()
  .reduce(
      0,
      (sum, str) -> sum + str.length(),
      Integer::sum
  );

Collector

Collectors.toCollection()

将数据转成Collection，只要是Collection 的实现都可以，例如ArrayList、HashSet ，该方法接受一个Collection 的实现对象或者说Collection 工厂的入参。包括后面也有Collectors.toList()、Collectors.toSet() ，这里只是指定了容器的类型。

Collectors.joining()

基本语法

Collectors.joining()                 // 直接拼接
Collectors.joining(CharSequence delimiter) // 指定分隔符
Collectors.joining(CharSequence delimiter, CharSequence prefix, CharSequence suffix)
// 指定分隔符 + 前缀 + 后缀

未完待续....

IO多路复用（埋坑）

Thu, 25 Jan 2024 00:00:00 GMT

可能的疑问

为什么不用多线程？
- 在很多rpc模型中可能会用到多线程，但是多线程上下文切换要处理操作句柄，线程多了的时候，代价很高。
单线程操作会不会因为堵塞导致数据丢失？
- 不会，因为DMA控制器会操作。

模型

`C10K`

是一个优化网络套接字以同时处理大量客户端连接的问题，表示处理 10000 个并发连接。

Socket模型

关于Socket，我看过最简洁的描述就是

Socket可以看成是一个四元组(Source:port, Desc:port)

他就是一个插头，一头插在客户端，一头插在服务端。他如何运行的呢？我们可以观察一下系统调用介绍也就是说在调用的时候，需要传入三个参数，篇幅过长我直接总结，感兴趣的可以通过

man 2 socket

自行查阅。

domain : 指定地址类型，比如ipv4 ipv6
type: 通信的类型，比如tcp, udp
protocol: socket传输协议编号，一般不设置。

返回值就是

On success, a file descriptor for the new socket is returned. On error, -1 is returned, and errno is set to in‐dicate the error.

Socket模型生命周期

简单粗暴的IO模型？

BIO

Blocking 显而易见这是堵塞的IO模型

public class SocketBio {
	public static void main(String[] args) throws IOException {
		ServerSocket server = new ServerSocket(9999);
		System.out.println("listening on 9999");
		while (true){
			Socket client = server.accept();
			System.out.printf("client %s #online\n", client.getPort());
			new Thread(new Runnable() {
				@Override
				public void run() {
					InputStream in = null;
					try{
						in = client.getInputStream();
						BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(in));
						while(true){
							String dateLine = bufferedReader.readLine();
							if(dateLine != null){
								System.out.printf("client %s #received: \n",client.getPort(), dateLine);
							}else{
								System.out.printf("client: %s #closed\n",client.getPort());
								client.close();
								break;
							}
						}
					} catch (Exception e) {
						e.printStackTrace();
					}
				}
			}).start();
		}
	}
}

NIO

No-Blocking

public class SocketNio {
	public static void main(String[] args) throws Exception {
		LinkedList<SocketChannel> clients = new LinkedList<>();
		ServerSocketChannel ss = ServerSocketChannel.open();
		ss.bind(new InetSocketAddress(9999));
		ss.configureBlocking(false);
		ByteBuffer buffer = ByteBuffer.allocateDirect(4096);
		while(true){
			SocketChannel client = ss.accept();
			if(client == null){

			}else{
				client.configureBlocking(false);
				int port = client.socket().getPort();
				System.out.printf("client: %d #accepted\n", port);
				clients.add(client);
			}
			Iterator<SocketChannel> iterator = clients.iterator();
			while(iterator.hasNext()){
				SocketChannel c = iterator.next();
				buffer.clear();
				int num = c.read(buffer);
				if(num > 0){
					buffer.flip();
					byte[] tmp = new byte[buffer.limit()];
					buffer.get(tmp);
					System.out.printf("client %d #received: %s \n", c.socket().getPort(), new String(tmp));
				}else if(num == -1){
					System.out.printf("Client %d disconnected\n", c.socket().getPort());
					iterator.remove();
					c.close();
				}
			}
		}
	}
}

IO多路复用

看上面的BIO和NIO的代码，我们就可以发现： BIO的缺点：

进程占据资源
上下文切换
...

NIO的缺点：

当连接多了之后，需要维护的东西很多。

于是可能会想到，能否只用一个进程去维护多个socket呢？

select

如果有很多请求（但是select限制的最大请求上限是1024）连接到server，select会对所有请求遍历，记录下有数据到达的请求IO，然后返回记录信息，客户端读取。所以当请求的数量很多但是数据请求很少的时候，会造成很多空读取。

int select(int maxfdp1,fd_set *readset,fd_set *writeset,fd_set *exceptset,const struct timeval *timeout)

参数说明

mafdfp1 描述待轮讯的连接的个数
fd_set: readset writeset exceptset 指定了让kernel读、写、异常的描述
timeout 描述了一个就绪可以花费多长时间。

原理图（copy来的

poll

poll和select没有太大的区别，都是通过管理多个描述符来进行轮讯，但是poll没有最大连接数限制，与此同时，poll的一个缺点就是：大量fd的数组被整体复制于用户态和内核的地址空间之间，而不论这些fd是否就绪，她的开销随着fd的数量增大线性增大。

# include <poll.h>
int poll ( struct pollfd * fds, unsigned int nfds, int timeout);

Epoll

epoll是在Linux-2.6中提出的，select和poll的增强版。 epoll使用一个文件描述管理多个fd，把用户关系的fd存放到kernel的一个事件表之中，这样用户空间和kernel的copy只需要一次。

大概就是： java端创建一个socket，fd是fd4，bind端口之后开始监听，这时候epoll会调用epoll_create(int size) 创建红黑树空间fd6，这个空间是被监听事件的数目，然后执行epoll_ctl，把fd6和fd4关联起来，当有链接有数据的时候，记录IO的编号，把这个编号存储在一个链表之中，当epoll调用epoll_wait的时候，就把这个事件相关的链表返回，之后调用程序只需要根据记录的信息，读写产生的事件IO即可。

#include <sys/epoll.h>
int epoll_create(int size);
int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
int epoll_wait(int epfd, struct epoll_event * events, int maxevents, int timeout);

先写这么多吧，后续在补充

Go接口型函数

Sat, 30 Dec 2023 00:00:00 GMT

Example

type Example interface{
    handle(key int) (int, error)
}

type ExampleFunc func(key int)(int, error)

func(t ExampleFunc) handle(key int)(int, error){
    return t(key)
}

这里定义了一个接口Example ，包含一个方法handle(key int) (int, error) ，然后定义了一个函数类型ExampleFunc，定义了Get方法，并且调用自己，这就是接口型函数。

why

假如这个GetTest是通过一个接口返回数据，接口类型作为参数，代表数据源.

func GetTest(example Example, key int) int{
    if buf, err := example.Get(key); err != nil{
        return nil
    }else{
        return buf
    }
}

方式一： ExampleFunc类型的函数作为参数

GetTest(ExampleFunc(func(key int) (int, error){
    return int(key), nil
}), 1)

// or
func test(key int) (int, error){
    return int(key), nil
}
GetTest(ExampleFunc(test), 1)

方式二：实现Example接口的结构体

type DB struct{params int}
func(db *DB)Query(){}
func(db *DB)Get(key int)(int, error){}

GetTest(new(DB), 1)

Go并发编程部分知识

Wed, 27 Dec 2023 00:00:00 GMT

锁

Go的sync提供了互斥锁sync.Mutex和读写锁sync.RWMutex

互斥锁 (sync.Mutex)

互斥顾名思义。使用互斥锁的两段程序不能同时运行。

Lock 加锁
Unlock 释放锁

我们可以通过在代码前调用Lock方法，在代码后面使用Unlock方法保证代码的互斥操作。类似C语言的PV操作。一个Go协程调用Lock方法获得锁之后，其他协程都会堵塞在Lock方法，直到释放锁。

读写锁(sync.RWMutex)

在实际应用中，很大一部分场景是，写操作 $\lt$ 读操作，所以如果对于一个读操作我们加锁，很有可能堵塞其他的读操作，而常识也知道，读操作不会影响数据。

所以如果想要保证读操作的安全性，只需要保证并发读操作的时候没有写操作即可。

Go语言的读写锁，分为读锁和写锁。读锁是允许同时进行的，但是写锁是互斥的。

读锁不互斥，没有写锁的情况下，读锁不堵塞，允许多个协程获取读锁。
写锁是互斥的，存在写锁，其他协程读锁会堵塞。
读锁和写锁是互斥的，如果存在读锁、写锁堵塞，存在写锁、读锁堵塞。

sync.RWMutex提供了四个方法

Lock 加写锁
Unlock 释放写锁
RLock 加读锁
RUnlock 释放读锁

这个读写锁是为了解决读多写少时的问题。

性能比较

为了方便测试，都是实现了接口。

假设一个读写操作都是1μs

Lock

package LockTest

import (
	"sync"
	"time"
)

type MUT interface {
	Read()
	Write()
}

type Lock struct {
	value int
	mu    sync.Mutex
}

func (L *Lock) Read() {
	L.mu.Lock()
	_ = L.value
	time.Sleep(time.Microsecond)
	L.mu.Unlock()
}

func (L *Lock) Write() {
	L.mu.Lock()
	L.value++
	time.Sleep(time.Microsecond)
	L.mu.Unlock()
}

RWLock

package LockTest

import (
	"sync"
	"time"
)

type RWLock struct {
	value int
	mu    sync.RWMutex
}

func (L *RWLock) Write() {
	L.mu.Lock()
	L.value++
	time.Sleep(time.Microsecond)
	L.mu.Unlock()
}

func (L *RWLock) Read() {
	L.mu.RLock()
	_ = L.value
	time.Sleep(time.Microsecond)
	L.mu.RUnlock()
}

test

package Test

import (
	"Go-Concurrency-Test_/LockTest"
	"sync"
	"testing"
)

func test(b *testing.B, mut LockTest.MUT, readNum, writeNum int) {
	for i := 0; i < b.N; i++ {
		var wg sync.WaitGroup
		for j := 0; j <= readNum; j++ {
			wg.Add(1)
			go func() {
				mut.Read()
				wg.Done()
			}()
		}

		for j := 0; j <= writeNum; j++ {
			wg.Add(1)
			go func() {
				mut.Write()
				wg.Done()
			}()
		}
		wg.Wait()
	}
}
func BenchmarkReadMore(b *testing.B)    { test(b, &LockTest.Lock{}, 8000, 1000) }
func BenchmarkReadRWMore(b *testing.B)  { test(b, &LockTest.RWLock{}, 8000, 1000) }
func BenchmarkWriteMore(b *testing.B)   { test(b, &LockTest.Lock{}, 8000, 1000) }
func BenchmarkWriteRWMore(b *testing.B) { test(b, &LockTest.RWLock{}, 8000, 1000) }
func BenchmarkLock(b *testing.B)        { test(b, &LockTest.Lock{}, 5000, 5000) }
func BenchmarkRWLock(b *testing.B)      { test(b, &LockTest.RWLock{}, 5000, 5000) }

运行测试

goos: linux
goarch: amd64
BenchmarkReadMore
BenchmarkReadMore-12       	       6	 262894692 ns/op
BenchmarkReadRWMore
BenchmarkReadRWMore-12     	      45	  24374298 ns/op
BenchmarkWriteMore
BenchmarkWriteMore-12      	       4	 258559273 ns/op
BenchmarkWriteRWMore
BenchmarkWriteRWMore-12    	      66	  22369855 ns/op
BenchmarkLock
BenchmarkLock-12           	       4	 293963420 ns/op
BenchmarkRWLock
BenchmarkRWLock-12         	      10	 123536948 ns/op

sync.mutex分析

原文章

互斥锁有两种状态：正常状态和饥饿状态。

在正常状态下，所有等待锁的 goroutine 按照FIFO顺序等待。唤醒的 goroutine 不会直接拥有锁，而是会和新请求锁的 goroutine 竞争锁的拥有。新请求锁的 goroutine 具有优势：它正在 CPU 上执行，而且可能有好几个，所以刚刚唤醒的 goroutine 有很大可能在锁竞争中失败。在这种情况下，这个被唤醒的 goroutine 会加入到等待队列的前面。如果一个等待的 goroutine 超过 1ms 没有获取锁，那么它将会把锁转变为饥饿模式。

在饥饿模式下，锁的所有权将从 unlock 的 goroutine 直接交给交给等待队列中的第一个。新来的 goroutine 将不会尝试去获得锁，即使锁看起来是 unlock 状态, 也不会去尝试自旋操作，而是放在等待队列的尾部。

如果一个等待的 goroutine 获取了锁，并且满足一以下其中的任何一个条件：(1)它是队列中的最后一个；(2)它等待的时候小于1ms。它会将锁的状态转换为正常状态。

正常状态有很好的性能表现，饥饿模式也是非常重要的，因为它能阻止尾部延迟的现象。

空结构体

package main

import (
	"fmt"
	"unsafe"
)

func main() {
	fmt.Println(unsafe.Sizeof(struct{}{}))
}

$ go run main.go
0

空结构体实例struct{} 不占据任何内存空间。

作用

实现`Set`

Go语言标准库没有提供set的实现，通常用map来实现。

实际上在使用set的时候，我们只关注key而不需要value，因此可以直接把value设置成struct{}

type Set map[string]struct{}

func (s Set) Exists(key string) bool {
	_, ok := s[key]
	return ok
}

func (s Set) Add(key string) {
	s[key] = struct{}{}
}

func (s Set) Delete(key string) {
	delete(s, key)
}

不发送数据的`channel`

func work(ch chan struct{}){
    <- ch
    fmt.Println("1")
    close(ch)
}

func main(){
    ch := make(chan struct{})
    go work(ch)
    ch <- struct{}{}
}

`goroutine`

控制协程数量

利用`channel`缓冲区

func MyRoutine() {
	var wg sync.WaitGroup

	ch := make(chan struct{}, 5)
	for i := 0; i <= 100; i++ {
		ch <- struct{}{}
		wg.Add(1)
		go func(i int) {
			defer wg.Done()
			log.Println(i)
			time.Sleep(time.Second)
			<-ch
		}(i)
	}
	wg.Wait()
}

make(chan sturct{}, 3) 创建缓冲区大小为3的channel，在没有被接收的情况下，最多发送三个消息就会被堵塞。

MIT6.824-Lab1

Tue, 19 Dec 2023 00:00:00 GMT

先来一张成功的截图

说明：基于本人的poor english 我选择阅读翻译版本的论文。

MapReduce框架

论文中对于MapReduce 主要分成四个角色：

User Program : 客户端，用来协调MapReduce任务。
Master: 用于分配任务、协调任务的进行。
Map Worker: 执行Map方法的进程。
Reduce Worker: 执行Reduer方法的进程。

输入数据以文件形式存储在系统中（在下一节讲到了）。在Master 进程的调整分配下运行map任务，生成了一些中间体，这些中间体是以k-v键值对形式存在的。另外一些进程运行了Reduer任务，产生最终输出。

Job: 整个MapReduce计算称为Job。
Task: 每一次MapReduce调用称为Task。

`Map`函数

Map函数使用一个key和一个value作为参数。

普遍上，key是输入文件的名字，我们一般不关心他，value是输入文件的内容。

对于一个单词计数器来说，value包含了要统计的文本，我们先把这些文本拆分单词，对于每一个单词，我们都调用一个emit。这个emit由MapReduce框架提供，并且这里的emit是属于Map的。emit接收两个参数，其中一个是key，一个是value。比如在单词计数器里面，就是调emit("apple","1")。在一个单词MapReduce Job中，这就是Map函数的实现。Map函数实际上不需要知道任何分布式相关的信息，不需要知道有多少台设备，不需要知道会通过网络来传输数据。

`Reduce`函数

Reduce函数的入参是某个特定的key的所有实例。所以接受的参数也是key和value。其中value是一个数组，里面的每一个元素都是Map函数输出的key作为实例的value。对于单词计数器来说，key就是一个单词，value是一串数组。在Reduce函数中，也有自己的emit函数，这里的emit函数只接受一个value参数，这个value会作为Reduce函数入参的key的最终输出。

What's More

实际上，对于复杂的阶段分析和迭代算法，比如评估网页的重要性，我们可能会把Reduce的输出在丢到Map里面继续迭代

Lab1

Lab1要求我们实现一个和Mapreduce类似机制的单词统计器。

输入文件在src/main中，文件名是pg-*.txt，要统计他们出现的单词和出现的次数。

首先观察文件结构

.
├── go.mod
├── Makefile
└── src
    ├── kvraft
    │   ├── client.go
    │   ├── common.go
    │   ├── config.go
    │   ├── server.go
    │   └── test_test.go
    ├── labgob
    │   ├── labgob.go
    │   └── test_test.go
    ├── labrpc
    │   ├── labrpc.go
    │   └── test_test.go
    ├── main
    │   ├── diskvd.go
    │   ├── lockc.go
    │   ├── lockd.go
    │   ├── mrmaster.go
    │   ├── mr-out-0
    │   ├── mrsequential.go
    │   ├── mrworker.go
    │   ├── pbc.go
    │   ├── pbd.go
    │   ├── pg-being_ernest.txt
    │   ├── pg-dorian_gray.txt
    │   ├── pg-frankenstein.txt
    │   ├── pg-grimm.txt
    │   ├── pg-huckleberry_finn.txt
    │   ├── pg-metamorphosis.txt
    │   ├── pg-sherlock_holmes.txt
    │   ├── pg-tom_sawyer.txt
    │   ├── pkg
    │   │   └── mod
    │   │       └── cache
    │   │           └── lock
    │   ├── test-mr.sh
    │   ├── viewd.go
    │   └── wc.so
    ├── models
    │   └── kv.go
    ├── mr
    │   ├── master.go
    │   ├── rpc.go
    │   └── worker.go
    ├── mrapps
    │   ├── crash.go
    │   ├── indexer.go
    │   ├── mtiming.go
    │   ├── nocrash.go
    │   ├── rtiming.go
    │   └── wc.go
    ├── porcupine
    │   ├── bitset.go
    │   ├── checker.go
    │   ├── model.go
    │   ├── porcupine.go
    │   └── visualization.go
    ├── raft
    │   ├── config.go
    │   ├── persister.go
    │   ├── raft.go
    │   ├── test_test.go
    │   └── util.go
    ├── shardkv
    │   ├── client.go
    │   ├── common.go
    │   ├── config.go
    │   ├── server.go
    │   └── test_test.go
    └── shardmaster
        ├── client.go
        ├── common.go
        ├── config.go
        ├── server.go
        └── test_test.go

mrmaster.go：用来启动master进程，启动后调用mr/master
mrworker.go：用来启动worker进程，启动后调用mr/worker
mrapps：是我们实际上要执行的任务，具体的map和reduce任务。
mr：实现lab1的文件夹：
- master.go：作为master节点所具备的功能
- worker.go：作为worker节点所具备的功能
- rpc.go：实现master和worker远程调用的数据结构

之前的版本没法处理crash-test 重新构建一个。现在有大概率失败，不知道为啥

程序的大概流程是这样的，我拿drawio摸一个

结构分析

rpc

type RequestTaskReply struct {
	Task       *Task
	NReduce    int
	DoneStatus bool
}

type ReportTaskResponse struct {
	WorkType  int // 0 map 1 reduce
	WorkId    int
	WorkFiles []string
}

type DoneTaskReply struct {
	X int
}

type TaskArgs struct{}

const (
	MapTask    = 0
	ReduceTask = 1

	Maping    = 0
	Reduceing = 1

	Ready    = 0
	Running  = 1
	Finished = 2
)

master

对于一个master 他需要有自己的结构

type Master struct {
	MapQue      []*Task // Map任务队列 未完成的
	ReduceQue   []*Task // Reduce任务队列 未完成的
	Files       []string // 要处理的文件
	MapCount    int // Map任务 现在看来是没用了，因为本来是我给MapQue写的是channel后来改成了切片
	ReduceCount int // Reduce任务数量 用于work生成temp文件
	Whiching    int // 正在进行什么任务，map or reduce
	Lock        sync.Mutex // 锁
	WorkID      int // id
	IsDone      bool // 是否完成
}

task的结构

type Task struct {
	TaskType   int // Task的类型 map or reduce
	MapId      int // map任务的id
	ReduceId   int // reduce任务id
	TaskStatus int // 状态 finished running ready
	InputFile  string // 操作的文件
	BeginTime  time.Time // 开始时间，用于处理crash
}

对于处理map任务和reduce任务的时候我是这样的：

一个worker刚开始的时候，肯定是处理map任务的，所以在创建work的时候就把map任务生成，

m.Lock.Lock()
for _, file := range files {
	task := Task{
		TaskType:   MapTask,
		InputFile:  file,
		TaskStatus: Ready,
		MapId:      0,
	}
	m.MapQue = append(m.MapQue, &task)
}

当处理完map任务，就直接把reduce任务生成，供后续去获取任务

		if flag := func() bool {
			m.Lock.Lock()
			for i := 0; i < len(m.MapQue); i++ {
				task := m.MapQue[i]
				if task.TaskStatus != Finished {
					m.Lock.Unlock()
					return false
				}
			}
			m.Lock.Unlock()
			return true
		}(); flag {
			m.Whiching = Reduceing
			m.Lock.Lock()
			for i := 0; i < m.ReduceCount; i++ {
				task := Task{
					TaskType:   ReduceTask,
					InputFile:  fmt.Sprintf("/var/tmp/mr-*-%v", i),
					TaskStatus: Ready,
					ReduceId:   0,
				}
				m.ReduceQue = append(m.ReduceQue, &task)
			}
			m.Lock.Unlock()
		}

对于work获取任务的时候，肯定是先判断正在处理什么，简易的代码

func (m *Master) GetTask(args *TaskArgs, reply *RequestTaskReply) error{
    if m.Done(){
        reply.DoneStatus = true
        return nil
    }
    if m.Whiching == Maping{
        for _, task := range m.MapQue{
            if task.TaskStatus == Ready{
                // 分发
                return nil
            }
        }
        // 根据上面的 判断是否完成map任务并生成reduce任务
    }else{
        for _, task := range m.ReduceQue{
            if task.TaskStatus == Ready{
                // 分发
                return nil
            }
        }
        flag := func(){}() // 判断reduce是否都完成
        if flag{ // 所有任务都已经完成
            reply.DoneStatus = true
			time.Sleep(time.Second * 2)
			m.Lock.Lock()
			m.IsDone = true
			m.Lock.Unlock()
        }
    }
}

work完成任务肯定是要上报的

func (m *Master) ReportWorkDone(args *ReportTaskResponse, reply *DoneTaskReply) error{
    if args.WorkType == MapTask{
        for task := range m.MapQue{
            // 先判断任务是否超时
            if task.MapId == mapWorkId && task.TaskStatus == Running{
                //把temp文件移到工作目录
                task.TaskStatus = Finished
				for _, file := range args.WorkFiles {
					src, err := os.Open(file)
                    defer src.Close()
					if err != nil {
						log.Fatal( err)
					}
					DIR, _ := os.Getwd()
					filename := filepath.Base(file)
					f := DIR + "/" + filename
					dst, err := os.Create(f)
                    defer dst.Close()
					if err != nil {
						log.Fatal(err)
					}
					_, err = io.Copy(dst, src)
					if err != nil {
						log.Fatal(err)
					}
				}
				break
            }
        }
    }else{
        // 同上
    }
}

对于处理crash任务，我的想法是开一个协程，定时扫描正在进行的任务类型的所有任务，如果超时10s以上，那么直接把任务状态设置为Ready等待分发即可，但是就是因为这个crash-test，我写了两个版本，第二个版本有时候可以pass，

crash.go

func maybeCrash() {
	max := big.NewInt(1000)
	rr, _ := crand.Int(crand.Reader, max)
	if rr.Int64() < 330 {
		// crash!
		os.Exit(1)
	} else if rr.Int64() < 660 {
		// delay for a while.
		maxms := big.NewInt(10 * 1000)
		ms, _ := crand.Int(crand.Reader, maxms)
		time.Sleep(time.Duration(ms.Int64()) * time.Millisecond)
	}
}

可以看出，有 1/3几率直接退出，1/3几率等到0-10s，1/3几率直接开始。

我的想法是，开一个协程，每两秒扫一下running的任务，如果超时了，就把状态设置Ready

func (m *Master) HeartBeatForTimeOut() { // 非心跳机制
	for !m.Done() {
		time.Sleep(2 * time.Second)
		m.Lock.Lock()
		if m.Whiching == Maping {
			for _, task := range m.MapQue {
				if task.TaskStatus == Running && (time.Since(task.BeginTime) > time.Duration(10*time.Second)) {
		task.TaskStatus = Ready
	}
			}
		} else {
			for _, task := range m.ReduceQue {
				if task.TaskStatus == Running && (time.Since(task.BeginTime) > time.Duration(10*time.Second)) {
		task.TaskStatus = Ready
	}
			}
		}
		m.Lock.Unlock()
	}
}

work

work结构

type OneWorker struct {
	WorkerID int // 工作 id
	Mapf     func(string, string) []KeyValue // 程序提供的Mapf
	Reducef  func(string, []string) string // 程序提供的Reducef
	Task     *Task // 执行的任务
	NReduce  int // educe任务的数量
	IsDone   bool // 是否完成
}

初始化的时候，直接for {}

func Worker(mapf func(string, string) []KeyValue, reducef func(string, []string) string) {
	worker := OneWorker{
		WorkerID: -1,
		Mapf:     mapf,
		Reducef:  reducef,
		IsDone:   false,
	}
	for !worker.IsDone {
		worker.work()
	}
}

对于一个work工作，在流程就是获取任务 -> 处理任务 -> 上报结果 -> 获取任务 ....

所以在work()里面就按照这个流程去工作

func (work *OneWorker) work() {
	task := work.RequireTask() // 获取任务
	if task != nil {
		work.Task = task
		if task.TaskType == MapTask {
			work.WorkerID = task.MapId
			intermediate := work.generateMapResult(task) // 调用mapf生成结果
			file := work.writeMapTempFiles(intermediate) // 写到文件里面
			work.TaskDone(file, MapTask) // 上报
		} else {
			work.WorkerID = task.ReduceId
			intermediate := work.generatorReduceResult(task.InputFile) // 调用reducef
			files := work.writeReduceTempFiles(task, intermediate) // 写到文件
			work.TaskDone(files, ReduceTask) // 上报
		}
	}
}

获取任务

func (work *OneWorker) RequireTask() *Task {
	args := TaskArgs{}
	reply := RequestTaskReply{}
	call("Master.GetTask", &args, &reply)
	if &reply != nil {
		if reply.DoneStatus { // 如果任务都完成了
			work.IsDone = true // 当前任务不需要处理
			return nil
		}
		work.NReduce = reply.NReduce
		return reply.Task
	} else {
		return nil
	}
}

调用mapf/reducef生成结果

func (work *OneWorker) generateMapResult(task *Task) []KeyValue {
	NowIntermediate := make([]KeyValue, 0) // 中间文件
	file, err := os.Open(task.InputFile)
	if err != nil {
		log.Fatal(err)
	}
	content, err := ioutil.ReadAll(file)
	if err != nil {
		log.Fatal(err)
	}
	file.Close()
	kva := work.Mapf(task.InputFile, string(content))
	NowIntermediate = append(NowIntermediate, kva...)
	return NowIntermediate
}

func (work *OneWorker) generatorReduceResult(task *Task) []KeyValue {
	intermedia := make([]KeyValue, 0)
	files, err := filepath.Glob(task.InputFile)
	if err != nil {
		log.Fatal(err)
	}
	for _, filepath := range files {
		file, err := os.Open(filepath)
		if err != nil {
			log.Fatal(err)
		}
		dec := json.NewDecoder(file)
		for {
			var kv KeyValue
			if err := dec.Decode(&kv); err != nil {
				break
			}
			intermedia = append(intermedia, kv)
		}
	}
    // mrsequential
	sort.Sort(ByKey(intermedia))
	res := make([]KeyValue, 0)
	i := 0
	for i < len(intermedia) {
		j := i + 1
		for j < len(intermedia) && intermedia[j].Key == intermedia[i].Key {
			j++
		}
		values := make([]string, 0)
		for k := i; k < j; k++ {
			values = append(values, intermedia[k].Value)
		}
		//defer work.CrashRecover()
		output := work.Reducef(intermedia[i].Key, values)
		kv := KeyValue{Key: intermedia[i].Key, Value: output}
		res = append(res, kv)
		i = j
	}
	return res
}

生成文件的时候，按照提示：

map任务
- 先利用ioutil.TempFile生成临时文件，等Json处理完，在Rename成mr-X-Y格式的文件
Reduce任务同上

任务上报直接报就行

func (work *OneWorker) TaskDone(files []string, Type int) {
	args := ReportTaskResponse{
		WorkType:  Type,
		WorkId:    work.WorkerID,
		WorkFiles: files,
	}
	reply := DoneTaskReply{}
	call("Master.ReportWorkDone", &args, &reply)
}

差不多就这些了

SpringBoot注解整理

Sat, 25 Nov 2023 00:00:00 GMT

SpringBoot 核心注解

@SpringBootApplication

标识这是一个springboot应用，这个注解是SpringBootConfiguration EnableAutoConfiguration CompoentScan的结合体。

@SpringBootApplication
public class MyApplication{
    public static void main(String[] args){
        SpringApplication.run(MyApplication.class, args);
    }
}

@Configuration

用它来代替applicationContext.xml文件，可以在这个注解下进行配置。通常用来自定义Bean

@Configuration
public class MyConfig{
    @Bean
    public Mybean bean(){
    }
}

@SpringBootConfiguration

是 Configuration 注解的变体，用来修饰 springboot的配置。

@EnableAutoConfiguration

允许springboot自动配置注解，开启之后，springboot会在自动配置Bean

CompoentScan

自动扫描@Compoent注解，包括@Service @Controller @Repository注册bean到context

@SpringBootApplication
@CompoentScan(basePackage="")
public class MyApplication{
    public static void main(String[] args){
        SpringApplication.run(MyApplication.class, args);
    }
}

@Autowired

可以自动把一个Bean注入到当前类中。默认情况下是根据类型进行匹配，可以用@Qualifier 进行限制

@Compoent
public class MyCompoent{
    @Autowired
    private UserImpl userImpl;
}

@Value

从配置文件或者环境变量获取值。

@Bean

用于定义一个Bean，放到IOC容器中。一般在@Configuration中使用。

原型注解

@Scope

常用于设置Bean的作用域，包括 Singleton、Prototype、Request、Session 等。默认情况下，Bean 是 Singleton 的。

Singleton: 默认，单例模式，全局仅有一个实例
Prototype：原型模式：每次获取Bean，都会有一个实例
Request: 针对每一次Http都会创建一个实例，同时该实例仅在当前的Http Requset有效
Session: 针对每次HTTP请求都会创建一个实例，同时该实例仅在当前的HTTP Session中有效

直接用字符串会有问题，用默认的参数：

ConfigurableBeanFactory.SCOPE_PROTOTYPE
ConfigurableBeanFactory.SCOPE_SINGLETON
WebApplicationContext.SCOPE_REQUEST
WebApplicationContext.SCOPE_SESSION

大部分业务直接用Singleton就可以，但是如果实例内有非静态变量，就会导致线程安全问题。设置为Prototype的时候，每次连接都会生成一个实例，GC频繁，性能下降。

@Lazy

用于设置Bean的延迟初始化。当IOC从XML文件、java配置或其他方式加载的时候，不会初始化这个Bean。

@DependsOn

表示Bean之间的依赖关系。IOC启动的时候，先创建@DependsOn标识的Bean。

SpringWeb常用注解

@Controller

标志着类是一个SpringMVC控制器，用来处理HTTP请求

@Controller
public class MyController{}

@RestController

他是 @Controller 和 @ResponseBody，用于创建Restful风格的控制器，表示控制器所有方法返回的都是Json格式的。

@RequsetMapping

用于映射Http请求，可以用value属性指定URL请求，可以用Method指定请求方法。

@RestController
@RequsetMapping("/v1")
publi class ApiController{

}

@GetMapping

相当于 @RequsetMapping(method=RequestMethod.GET)

@RestController
@RequsetMapping("/v1")
publi class ApiController{
    @GetMapping("/hello")
    public void handleHello(){}
}

@PostMapping

相当于 @RequsetMapping(method=RequsetMethod.Post)

@PutMapping

同上

@DeleteMapping

同上

@RequestParma

用于将请求参数映射到方法的参数当中，可以使用value属性指定参数名，required指定是否必填，defaultValue指定默认值

@RestController
@RequsetMapping("/v1")
publi class ApiController{
    @GetMapping("/hello")
    public String handleHello(@RequestParma("name") string name){
        return "hello " + name;
    }
}

@PathVariable

用于把URL的占位符映射到方法的参数中。可以使用value属性指定占位符名称。

@RestController
@RequsetMapping("/v1")
publi class ApiController{
    @GetMapping("/{name}")
    public String handleName(@PathVariable("name") String name){

    }
}

@RequestBody

用于从请求体中获取数据。通常处理Post，Put请求

@RestController
@RequestMapping("/api")
public class MyController {
    @PostMapping("/greeting")
    public String greeting(@RequestBody GreetingRequest request) {
        return "Hello, " + request.getName() + "!";
    }
}

@Data
public class GreetingRequest {
    private String name;
}

@ResponseBody

注解表示该方法返回的结果直接输出到响应体中。

@ResponseStatus

注解用于指定请求处理完成后的状态码。

@Cacheable

表示该方法的结果被缓存，假如参数相同，就调用缓存的结果。

@CachePut

表示方法的结果应该被缓存起来，下次调用该方法时，不会返回缓存结果，而是重新计算结果并缓存起来。

@CacheEvict

表示方法执行后从缓存中删除指定项。

测试注解

@SpringBootTest

它会创建一个完整的 Spring 应用程序上下文，并在测试期间使用它

数据库相关

@Transactional

用于指定一个方法需要在事务中执行。默认情况下，只有 RuntimeException 会触发事务回滚。

@Reposity

用于标记数据访问层，表示这个类是一个数据仓库

@Entity

用于标记实体类，表示这个类是一个JPA实体，与数据库中的表对应。

@Id

标记主键字段

@GeneratedValue

指定主键的生成策略。

@Column

指定实体属性和数据库表之间的映射关系。

实现一个分布式缓存

Thu, 02 Nov 2023 00:00:00 GMT

分布式缓存

缓存非常常见，比如网站的CDN缓存，Redis集群等。

对于类似map的k-v 缓存策略，大概有几个问题

内存不够？
- 对于这个问题，我们可以采取一个策略，对于被策略淘汰的键值，我们在新增键值的时候替换掉即可。
性能不够？
- 这个可以通过多机分布式来实现，但是我写的没有实现多机，只实现了多进程。
负载均衡？
- 我只实现了一致性哈希，应该还需要一个master来调控，我没写....`
缓存击穿？
- 实现思路大概就是，对于多次相同的请求，给一个缓冲，实现只处理一次请求，然后多次返回这个返回值。
DO or TODO
- [x] LRU
- [x] 单机并发、分布式节点
- [x] 防止缓存击穿
- [ ] PRC

实现

LRU淘汰策略

LRU 顾名思义 Least Recently Used ，最近最少使用，相对于LFR和FIFO来说，应该是最适合的。

我们维护一个队列，对于使用过的，就放到队列最前面，显而易见，淘汰的时候只需要把队尾删掉即可。

数据结构

map：用来存储缓存的键值
双向链表：把所有的key映射到上面，这样的操作都是O(1)的

type Value interface { // Value 范型
	Len() int
}

type Entry struct { // 双向链表上面的
	key   string
	value Value
}

type Cache struct {
	maxBytes     int64 // 最大的容量
	nBytes       int64 // 当前已经使用的
	List         *list.List // 双向链表
	cache        map[string]*list.Element // 映射的数据
	handleRemove func(key string, value Value) // 自定义remove 类似于 删掉之后的后续操作
}

//new操作
func New(maxBytes int64, handleRemove func(string, Value)) *Cache {
	return &Cache{
		maxBytes:     maxBytes,
		List:         list.New(),
		cache:        make(map[string]*list.Element),
		handleRemove: handleRemove,
	}
}

查找

查找操作就是，直接在list上面查找，找到之后就把*list.element移动到维护的队头。

func (c *Cache) Get(key string) (Value, bool) {
	if value, ok := c.cache[key]; ok {
		c.List.MoveToFront(value)
		kv := value.Value.(*Entry) // 断言
		return kv.value, true
	}
	return nil, false
}

删除

删除操作就是，查找队尾，如果不为空就remove，然后更新一下信息。

func (c *Cache) Delete() {
	ele := c.List.Back()
	if ele != nil {
		c.List.Remove(ele)
		kv := ele.Value.(*Entry)
		delete(c.cache, kv.key)
		c.nBytes -= int64(len(kv.key)) + int64(kv.value.Len())
		if c.handleRemove != nil {
			c.handleRemove(kv.key, kv.value)
		}
	}
}

添加

添加的时候，基本思路就是，如果存在，就更新value，如果不存在就扔到对头，然后执行淘汰。

func (c *Cache) Add(key string, value Value) {
	if ele, ok := c.cache[key]; ok {
		c.List.MoveToFront(ele)
		kv := ele.Value.(*Entry)
		c.nBytes += int64(len(kv.key)) + int64(kv.value.Len())
		kv.value = value
	} else {
		ele := c.List.PushFront(&Entry{key, value})
		c.cache[key] = ele
		c.nBytes += int64(len(key)) + int64(value.Len())
	}
	for c.maxBytes != 0 && c.maxBytes < c.nBytes {
		c.Delete()
	}
}

一致性哈希

为什么要使用一致性哈希？

我们考虑这么一个问题，在分布式缓存中，当一个节点接收到一个请求，但是该节点并没有存储缓存值，那么他要面临：从谁那里获取数据。我们假设一共有五个节点。

随机选择节点：每次将会有$\frac{1}{5}$ 的概率，效率很低
自定义哈希：我们对于每一个key ，利用某种算法，转成整数，然后 $% (sum(serve))$ 得到一个分布式节点的id，但是这种算法有个明显的缺陷是，假如有节点下线了，那么所有缓存都会失效

算法原理

步骤

一致性哈希维护一个环，他把key映射到$2^{32}$大小的环上

计算节点的哈希值，放到环上
计算key的哈希值，放到环上，顺时针找到的第一个节点，就是应该选取的节点。

数据倾斜

假如系统节点太少，很容易导致key的倾斜。例如上面例子中的 peer2，peer4，peer6 分布在环的上半部分，下半部分是空的。那么映射到环下半部分的 key 都会被分配给 peer2，key 过度向 peer2 倾斜，缓存节点间负载不均。

应对这个问题，引出了虚拟节点的概念，一个真实节点对应多个虚拟节点。

type Hash func(data []byte) uint32

type Map struct {
	hash     Hash // 自定义哈希算法
	replicas int            //虚拟节点倍数
	keys     []int          // 哈希环
	hasMap   map[int]string // 虚拟节点和真实节点
}

func NewHash(replicas int, has Hash) *Map {
	m := &Map{
		hash:     has,
		replicas: replicas,
		keys:     make([]int, 0),
		hasMap:   make(map[int]string),
	}
	if m.hash == nil {
		m.hash = crc32.ChecksumIEEE
	}
	return m
}

添加节点

func (m *Map) Add(keys ...string) {
	for _, key := range keys {
		for i := 0; i < m.replicas; i++ {
			hash := int(m.hash([]byte(strconv.Itoa(i) + key)))
			m.keys = append(m.keys, hash)
			m.hasMap[hash] = key
		}
	}
	sort.Ints(m.keys)
}

获取节点


func (m *Map) Get(key string) string {
	if len(m.keys) == 0 {
		return ""
	}
	hash := int(m.hash([]byte(key)))
	idx := sort.Search(len(m.keys), func(i int) bool {
		return m.keys[i] >= hash
	})
	return m.hasMap[m.keys[idx%len(m.keys)]]
}

第一次ICPC游记

Thu, 23 Jun 2022 00:00:00 GMT

第一次参加，摆烂很久了，要不是因为我眼瞎可以拿个银的，唉，还是菜，明年继续。

早在几个月之前，wqy就拉我组队，我去了肯定是拖后腿啊哈哈哈哈。

比赛前几次的训练赛我们都没参加，主要是疫情封校学长进不来，我们以为就我俩参加，没啥信心了就摆烂。

我自己也是基本都不写acm题目了，天天写java，写单子赚钱，写作业。

考试之前我居然都不知道自己的队名，在见过一次面的wqy的指引下找到了我们的桌子，在最后面，旁边的空调坏了，不过旁边桌子是大三学长，都是大佬，可以听听他们的思路哈哈哈哈。虽然他们失利打铁了。

比赛开始之后我们看了看题，昏沉沉的，觉得A能开，就开A，发现我们没思路也不会，然后看后面的题，都是一眼会然后被否，以至于快12点我们还没写代码，就没信心啦，都昏昏沉沉，然后我去上了个厕所，回来之后也不会。

别的队伍已经最多的过了俩题了，我们还没过，以为得爆零了，就一点斗志也没了。

12点多我突然会写A了，然后开写，我的做法是纯加法+打表，但是打表的时候我把19写成18了，导致调了很久都没发现，交了得10遍，不然就银牌！

然后有个题我们决定破釜沉舟，写一个大部分范围的完全背包+摆烂输出，结果过了，士气大增直接把另一个提过了。

我们在一小时内，连过三题，直接拿下铜牌！

反观自己整个路程，其实我是比较摆烂的，得亏运气好，不然今年得打铁了，好好学啦得，不能留下遗憾。

鲁哥他们还是比较可惜的，实力都很强但是没做出来。

明年加油，保银争金！

服务器搭建Hexo博客

Thu, 24 Mar 2022 00:00:00 GMT

我服务器是腾讯云轻量hk，搭建之后访问速度还是很快的。比上cdn的Typecho 快多了

一、在本地Windows上搭建Hexo

1.1 配置本地`node`环境

node下载官网下载，可以的话推荐使用 nvm 安装
打开cmd查看node安装情况
```
node -v
npm -v
```
配置全局环境
- 进入安装目录，创建文件夹node_global和node_cache 并执行
```
npm config set prefix "D:\programming\nodejs\node_global"
npm config set cache "D:\programming\nodejs\node_cache"
```
- 环境配置：新增环境变量NODE_PATH和添加Path，两个值都为 \node_global的目录位置
安装hexo-cli
```
npm i hexo-cli -g
hexo
```
随便找个地方初始化文件，执行如下命令：
```
mkdir hexo-blog
cd hexo-blog && npm init -y
```

1.2初始化`hexo`项目

在中的hexo-blog文件下初始化
```
hexo init myblog && cd myblog
npm i
```

下载主题

这里我用的是next主题，其他同理

git clone https://github.com/iissnan/hexo-theme-next themes/next

在本地配置文件_confing.yml中设置theme属性
本地执行hexo项目，添加start脚本
```
"start" : "hexo clean && hexo g && hexo s"
```
然后执行命令
```
npm run start
```
打开 http://localhost:4000 验证效果吧

1.3`git`环境搭建

git安装：官网下载

生成ssh认证，执行如下命令

git config --global user.name "yourname"
git config --global user.email youremail@example.com
ssh-keygen -t rsa -C "youremail@example.com"
git config --global core.autocrlf false  // 禁用自动转换，

最后获取到的ssh认证在C:\Users\yourname\.ssh中

二、服务器配置

这个之前写过来着

教程是Centos服务器，Ubuntu Debian 命令自行更换即可。

1.1 搭建远程`Git`私库

在服务器安装 git

git --version // 如无，则安装
yum install curl-devel expat-devel gettext-devel openssl-devel zlib-devel perl-devel
yum install -y git

创建用户并配置其仓库

useradd git
passwd git // 设置密码
su git // 这步很重要，不切换用户后面会很麻烦
cd /home/git/
mkdir -p projects/blog // 项目存在的真实目录
mkdir repos && cd repos
git init --bare blog.git // 创建一个裸露的仓库
cd blog.git/hooks
vi post-receive // 创建 hook 钩子函数，输入了内容如下

#!/bin/sh
git --work-tree=/home/git/projects/blog --git-dir=/home/git/repos/blog.git checkout -f

添加完毕后修改权限

chmod +x post-receive
exit // 退出到 root 登录
chown -R git:git /home/git/repos/blog.git // 添加权限

测试git仓库是否可用，另找空白文件夹
```
git clone git@server_ip:/home/git/repos/blog.git
```
如果能把空仓库拉下来，就说明 git 仓库搭建成功了
建立ssh信任关系，在本地电脑
```
ssh-copy-id -i C:/Users/yourname/.ssh/id_rsa.pub git@server_ip
ssh git@server_ip // 测试能否登录
```
注：此时的 ssh 登录 git 用户不需要密码！否则就有错，请仔细重复步骤 3-5

为了安全起见禁用 git 用户的 shell 登录权限，从而只能用 git clone，git push 等登录

cat /etc/shells // 查看 git-shell 是否在登录方式里面
which git-shell // 查看是否安装
vi /etc/shells
添加上2步显示出来的路劲，通常在 /usr/bin/git-shell

修改/etc/passwd中的权限

// 将原来的
git:x:1000:1000::/home/git:/bin/bash

// 修改为
git:x:1000:1000:,,,:/home/git:/usr/bin/git-shell

1.2搭建`nginx`服务器

下载并安装nginx

cd /usr/local/src
wget http://nginx.org/download/nginx-1.15.2.tar.gz
tar xzvf nginx-1.15.2.tar.gz
cd nginx-1.15.2
./configure // 如果后面还想要配置 SSL 协议，就执行后面一句！
./configure --prefix=/usr/local/nginx --with-http_stub_status_module --with-http_ssl_module --with-file-aio --with-http_realip_module
make && make install
alias nginx='/usr/local/nginx/sbin/nginx' // 为 nginx 取别名，后面可直接用

配置nginx文件
- 先启动是否安装成功
```
nginx // 直接来！浏览器查看 server_ip，默认是 80 端口
```
- 修改配置文件
```
nginx -s stop // 先停止nginx
cd /usr/local/nginx/conf
vi nginx.conf
```
  修改root解析路径，如下图
  
  同时将 user 改为root如下图，不然nginx无法访问 /home/git/projects/blog
```
nginx -s reload
```

三、发布

至此我们就把本地和服务器的环境全部搭建完成，现在利用 hexo 配置文件进行链接

配置`_config.yml`文件

编辑_config.yml的 deploy 属性

deploy:
  type: git
  repo: git@ip:/home/git/repos/blog.git
  branch: master

在 package.json 中添加npm脚本
```
"dd": "hexo clean && hexo g -d"
```
若在本地调试则使用
```
hexo clean && hexo g && hexos
```
或者要是跟我一样配置了scripts
```
npm run start
```
若发布
```
hexo clean && hexo g -d
```
或者要是跟我一样配置了scripts
```
npm run dd
```

给女朋友写的C语言期末笔记

Wed, 23 Mar 2022 00:00:00 GMT

秘籍

ps ：好多定义是百度百科的，看不懂一定要问我~

语言基础

什么是 `main()` ？

可以理解为程序运行时就会执行 main() 中的代码。

最后的 return 0; 表示程序运行成功。默认情况下，程序结束时返回 0 表示一切正常，否则返回值表示错误代码。这个值返回给谁呢？其实就是调用你写的程序的系统或外部程序，它会在你的程序结束时接收到这个返回值。如果不写 return 语句的话，程序正常结束默认返回值也是 0。

数据类型

C 内置了六种基本数据类型：

| 类型 | 关键字 | | -------: | :----- | | | | | 字符型 | char | | 整型 | int | | 浮点型 | float | | 双浮点型 | double | | 无类型 | void |

对于 int 关键字，可以使用如下修饰关键字进行修饰：

符号性：

signed：表示带符号整数（默认）；
unsigned：表示无符号整数。

大小：

short：表示至少 $16$位整数；
long：表示至少 $32$ 位整数；
long long：表示至少 $64$ 位整数。

定义变量

简单地说，定义一个变量，需要包含类型说明符（指明变量的类型），以及要定义的变量名。

例如，下面这几条语句都是变量定义语句。

int yz;
double yrh;
char yrh = 's';

变量作用域

作用域是变量可以发挥作用的代码块。

全局变量的作用域，自其定义之处开始，至文件结束位置为止。

局部变量的作用域，自其定义之处开始，至代码块结束位置为止。

由一对大括号括起来的若干语句构成一个代码块。

int g = 20;  // 定义全局变量
int main() {
  int g = 10;         // 定义局部变量
  printf("%d\n", g);  // 输出 g
  return 0;
}

如果一个代码块的内嵌块中定义了相同变量名的变量，则内层块中将无法访问外层块中相同变量名的变量。

例如上面的代码中，输出的$g$的值将是$10$ 。因此为了防止出现意料之外的错误，请尽量避免局部变量与全局变量重名的情况。

常量

常量是固定值，在程序执行期间不会改变。

常量的值在定义后不能被修改。定义时加一个 const 关键字即可。

const int a = 2;
a = 3;

如果修改了常量的值，在编译环节就会报错：error: assignment of read-only variable‘a’。

`scanf` 与 `printf`

scanf 与 printf 其实是 C 语言提供的函数。

`scanf` 为什么会有 `&`

在这里，& 实际上是取址运算符，返回的是变量在内存中的地址。而 scanf 接收的参数就是变量的地址。具体可能要在指针才能完全清楚地说明，现在只需要记下来就好了。

什么是 `\n`

\n 是一种 转义字符，表示换行。

转义字符用来表示一些无法直接输入的字符，如由于字符串字面量中无法换行而无法直接输入的换行符，由于有特殊含义而无法输入的引号，由于表示转义字符而无法输入的反斜杠。

常用的转义字符有：

\t 表示制表符。
\\ 表示 \。
\" 表示 "。
\0 表示空字符，用来表示 C 风格字符串的结尾。
\r 表示回车。Linux 中换行符为 \n，Windows 中换行符为 \r\n。在 OI 中，如果输出需要换行，使用 \n 即可。但读入时，如果使用逐字符读入，可能会由于换行符造成一些问题，需要注意。例如，gets 将 \n 作为字符串结尾，这时候如果换行符是 \r\n，\r 就会留在字符串结尾。
特殊地，%% 表示 %，只能用在 printf 或 scanf 中，在其他字符串字面量中只需要简单使用 % 就好了。

#include <cstdio>

int main() {
  int x, y;
  scanf("%d%d", &x, &y);   // 读入 x 和 y
  printf("%d\n%d", y, x);  // 输出 y，换行，再输出 x
  return 0;
}

其中，%d 表示读入/输出的变量是一个有符号整型 (int 型）的变量。

类似地：

%s 表示字符串。
%c 表示字符。
%lf 表示双精度浮点数 (double)。
%lld 表示长整型 (long long)。根据系统不同，也可能是 %I64d。
%u 表示无符号整型 (unsigned int)。
%llu 表示无符号长整型 (unsigned long long)，也可能是 %I64u

除了类型标识符以外，还有一些控制格式的方式。许多都不常用，选取两个常用的列举如下：

%1d 表示长度为 1 的整型。在读入时，即使没有空格也可以逐位读入数字。在输出时，若指定的长度大于数字的位数，就会在数字前用空格填充。若指定的长度小于数字的位数，就没有效果。
%.6lf，用于输出，保留六位小数。

这两种运算符的相应地方都可以填入其他数字，例如 %.3lf 表示保留三位小数。

运算

算术运算符

| 运算符 | 功能 | | :----------- | :--- | | + （单目） | 正 | | - （单目） | 负 | | * （双目） | 乘法 | | / | 除法 | | % | 取模 | | + （双目） | 加法 | | - （双目） | 减法 |

单目与双目运算符

算术运算符中有两个单目运算符（正、负）以及五个双目运算符（乘法、除法、取模、加法、减法），其中单目运算符的优先级最高。

其中取模运算符 % 意为计算两个整数相除得到的余数，即求余数。

而 - 为双目运算符时做减法运算符，如 2-1 ；为单目运算符时做负值运算符，如 -1 。

使用方法如下

yz=y-r*h

得到的 yz 的运算值遵循数学中加减乘除的优先规律，首先进行优先级高的运算，同优先级自左向右运算，括号提高优先级。

算术运算中的类型转换

对于双目算术运算符，当参与运算的两个变量类型相同时，不发生类型转换，运算结果将会用参与运算的变量的类型容纳，否则会发生类型转换，以使两个变量的类型一致。

转换的规则如下：

先将 char ， short 等类型提升至 int （或 unsigned int ，取决于原类型的符号性）类型；
若存在一个变量类型为 long double ，会将另一变量转换为 long double 类型；
否则，若存在一个变量类型为 double ，会将另一变量转换为 double 类型；
否则，若存在一个变量类型为 float ，会将另一变量转换为 float 类型；
否则（即参与运算的两个变量均为整数类型）：
- 若两个变量符号性一致，则将位宽较小的类型转换为位宽较大的类型；
- 否则，若无符号变量的位宽不小于带符号变量的位宽，则将带符号数转换为无符号数对应的类型；
- 否则，若带符号操作数的类型能表示无符号操作数类型的所有值，则将无符号操作数转换为带符号操作数对应的类型；
- 否则，将带符号数转换为相对应的无符号类型。

例如，对于一个整型（ int ）变量和另一个双精度浮点型（ double ）类型变量：

x/3 的结果将会是整型；
x/3.0 的结果将会是双精度浮点型；
x/y 的结果将会是双精度浮点型；
x*1/3 的结果将会是整型；
x*1.0/3 的结果将会是双精度浮点型；

自增/自减运算符

有时我们需要让变量进行增加 1（自增）或者减少 1（自减），这时自增运算符 ++ 和自减运算符 -- 就派上用场了。

自增/自减运算符可放在变量前或变量后面，在变量前称为前缀，在变量后称为后缀，单独使用时前缀后缀无需特别区别，如果需要用到表达式的值则需注意

i = 100;

yz1 = i++;  // yz1 = 100，先 yz1 = i，然后 i = i + 1

i = 100;

yz2 = ++i;  // yz2 = 101，先 i = i + 1，然后赋值 yz2

i = 100;

yz3 = i--;  // yz3 = 100，先赋值 yz3，然后 i = i - 1

i = 100;

yz4 = --i;  // yz4 = 99，先 i = i - 1，然后赋值 yz4

复合赋值运算符

复合赋值运算符实际上是表达式的缩写形式。

yz = yz + 2 可以写成 yz += 2

yz = yz - 2 可以写成 yz -= 2

yz = yz * 2 可以写成 yz *= 2

yz = yz / 2 可以写成 yz /= 2

比较运算符

| 运算符 | 功能 | | :----- | :------- | | > | 大于 | | >= | 大于等于 | | < | 小于 | | <= | 小于等于 | | == | 等于 | | != | 不等于 |

其中特别需要注意的是要将等于运算符 == 和赋值运算符 = 区分开来，这在判断语句中尤为重要。

if(op=1) 与 if(op==1) 看起来类似，但实际功能却相差甚远。第一条语句是在对 op 进行赋值，若赋值为非 0 时为真值，表达式的条件始终是满足的，无法达到判断的作用；而第二条语句才是对 op 的值进行判断。

逻辑运算符

| 运算符 | 功能 | | :----- | :----- | --- | ------ | | && | 逻辑与 | | | | | 逻辑或 | | ! | 逻辑非 |

Result = op1 && op2;  // 当 op1 与 op2 都为真时则 Result 为真

Result = op1 || op2;  // 当 op1 或 op2 其中一个为真时则 Result 为真

Result = !op1;  // 当 op1 为假时则 Result 为真

分支

if 语句

if (条件) {
  主体;
}

if 语句通过对条件进行求值，若结果为真（非 0），执行语句，否则不执行。

如果主体中只有单个语句的话，花括号可以省略。

if...else 语句

if (条件) {  主体1;} else {  主体2;}

if...else 语句和 if 语句类似，else 不需要再写条件。当 if 语句的条件满足时会执行 if 里的语句，if 语句的条件不满足时会执行 else 里的语句。同样，当主体只有一条语句时，可以省略花括号。

else if 语句

if (条件1) {  主体1;} else if (条件2) {  主体2;} else if (条件3) {  主体3;} else {  主体4;}

else if 语句是 if 和 else 的组合，对多个条件进行判断并选择不同的语句分支。在最后一条的 else 语句不需要再写条件。例如，若条件 1 为真，执行主体 1，条件 3 为真而条件 1 和条件 2 都为假，执行主体 3，所有的条件都为假才执行主体 4。

实际上，这一个语句相当于第一个 if 的 else 分句只有一个 if 语句，就将花括号省略之后放在一起了。如果条件相互之间是并列关系，这样写可以让代码的逻辑更清晰。

switch 语句

switch (选择句) {
  case 标签1:
    主体1;
  case 标签2:
    主体2;
  default:
    主体3;
}

switch 语句执行时，先求出选择句的值，然后根据选择句的值选择相应的标签，从标签处开始执行。其中，选择句必须是一个整数类型表达式，而标签都必须是整数类型的常量。例如：

int i = 1;  // 这里的 i 的数据类型是整型 ，满足整数类型的表达式的要求
switch (i) {
  case 1:
    printf(" i love yz");
}

char i = 'A';
// 这里的 i 的数据类型是字符型 ，但 char
// 也是属于整数的类型，满足整数类型的表达式的要求
switch (i) {
  case 'A':
    printf(" i love yz");
}

switch 语句中还要根据需求加入 break 语句进行中断，否则在对应的 case 被选择之后接下来的所有 case 里的语句和 default 里的语句都会被运行。具体例子可看下面的示例。

char i = 'B';
switch (i) {
  case 'A':
    printf(" i love yz");
    break;

  case 'B':
    printf(" yz love yz");

  default:
    printf(" yz love me");
}

switch 的 case 分句中也可以选择性的加花括号。不过要注意的是，如果需要在 switch 语句中定义变量，花括号是必须要加的。例如：

char i = 'B';switch (i) {  case 'A': {    int i = 1, j = 2;    printf("i\n");    ans = i + j;    break;  }  case 'B': {    int qwq = 3;   printf("love\n");    ans = qwq * qwq;    break;  }  default: {    printf("yz\n");  }}

循环

`for`语句

for (初始化; 判断条件; 更新) {  循环体;}

读入 n 个数：

for (int i = 1; i <= n; i++)	scanf("%d",&a[i]);

for 语句的三个部分中，任何一个部分都可以省略。其中，若省略了判断条件，相当于判断条件永远为真。

while 语句

while (判断条件) {  循环体;}

do...while 语句

do {  循环体;} while (判断条件);

与 while 语句的区别在于，do...while 语句是先执行循环体再进行判断的。

三种语句的联系

可能需要当面讲解

// for 语句for (statement1; statement2; statement3) {  statement4;}// while 语句statement1;while (statement2) {  statement4;  statement3;}

// while 语句statement1;while (statement2) {  statement1;}// do...while 语句do {  statement1;} while (statement2);

while (1) {  // do something...}for (;;) {  // do something...}

可以看出，三种语句可以彼此代替，但一般来说，语句的选用遵守以下原则：

循环过程中有个固定的增加步骤（最常见的是枚举）时，使用 for 语句；
只确定循环的终止条件时，使用 while 语句；
使用 while 语句时，若要先执行循环体再进行判断，使用 do...while 语句。一般很少用到，常用场景是用户输入。

break 与 continue 语句

break 语句的作用是退出循环。

continue 语句的作用是跳过循环体的余下部分，回到循环的开头（for 语句的更新，while 语句的判断条件）。

for (int i = 1; i <= 10; ++i) {  printf("%d\n",i);  if (i > 3) break;  if (i > 2) continue;  printf("%d\n",i);}/*输出如下：112234*/

break 与 continue 语句均可在三种循环语句的循环体中使用。

一般来说，break 与 continue 语句用于让代码的逻辑更加清晰，例如：

// 逻辑较为不清晰，大括号层次复杂for (int i = 1; i <= n; ++i) {  if (i != x) {    for (int j = 1; j <= n; ++j) {      if (j != x) {        // do something...      }    }  }}// 逻辑更加清晰，大括号层次简单明了for (int i = 1; i <= n; ++i) {  if (i == x) continue;  for (int j = 1; j <= n; ++j) {    if (j == x) continue;    // do something...  }}

// for 语句判断条件复杂，没有体现“枚举”的本质for (int i = l; i <= r && i % 10 != 0; ++i) {  // do something...}// for 语句用于枚举，break 用于“到何时为止”for (int i = l; i <= r; ++i) {  if (i % 10 == 0) break;  // do something...}

// 语句重复，顺序不自然

statement1;
while (statement3) {
  statement2;
  statement1;
}

// 没有重复语句，顺序自然

while (1) {
  statement1;
  if (!statement3) break;
  statement2;
}

高级结构

数组

数组是存放相同类型对象的容器，数组中存放的对象没有名字，而是要通过其所在的位置访问。数组的大小是固定的，不能随意改变数组的长度。

定义数组

数组的声明形如 a[d]，其中，a 是数组的名字，d 是数组中元素的个数。在编译时，d 应该是已知的，也就是说，d 应该是一个整型的常量表达式。

int d1 = 42;
const int d2 = 42;
int arr1[d1];  // 错误：d1 不是常量表达式
int arr2[d2];  // 正确：arr2 是一个长度为 42 的数组

不能将一个数组直接赋值给另一个数组：

int arr1[3];
int arr2 = arr1;  // 错误
arr2 = arr1;      // 错误

访问数组元素

可以通过下标运算符 [] 来访问数组内元素，数组的索引（即方括号中的值）从 0 开始。以一个包含 10 个元素的数组为例，它的索引为 0 到 9，而非 1 到 10。为了使用方便，我通常会将数组开大一点，不使用数组的第一个元素，从下标 1 开始访问数组元素。

例 1：从标准输入中读取一个整数$n$ ，再读取$n$个数，存入数组中。其中，$n \leq 1000$

#include <stdio.h>int main(){    int a[1010], n;//可以定义大一点 用不到没关系 也别太离谱  	scanf("%d",&n);    int i ;    for(i = 1; i <= n; i++)//从下标1开始       scanf("%d",&a[i]);}

例 2：（接例 1）求和数组 arr 中的元素，并输出和。满足数组中所有元素的和在int范围内

#include <stdio.h>int main(){    int a[1010], n, sum = 0;//可以定义大一点 用不到没关系 也别太离谱  	scanf("%d",&n);    int i ;    for(i = 1; i <= n; i++)//从下标1开始       scanf("%d",&a[i]);   	for(i = 1; i <= n; i++)        sum += a[i];    printf("%d",sum);}

多维数组

多维数组的实质是「数组的数组」，即外层数组的元素是数组。一个二维数组需要两个维度来定义：数组的长度和数组内元素的长度。访问二维数组时需要写出两个索引：

int arr[3][4];  // 一个长度为 3 的数组，它的元素是「元素为 int 的长度为的 4                // 的数组」arr[2][1] = 1;  // 访问二维数组

我们经常使用嵌套的 for 循环来处理二维数组。

const int maxn = 1001;int pic[maxn][maxn];int n, m;scanf("%d%d",&n,&m);for (int i = 1; i <= n; i++)  for (int j = 1; j <= m; j++)  	scanf("%d",&pic[i][j]);

函数

函数的声明

编程中的函数（function）一般是若干语句的集合。我们也可以将其称作“子过程（subroutine）”。在编程中，如果有一些重复的过程，我们可以将其提取出来，形成一个函数。函数可以接收若干值，这叫做函数的参数。函数也可以返回某个值，这叫做函数的返回值。

声明一个函数，我们需要返回值类型、函数的名称，以及参数列表。

// 返回值类型 int// 函数的名称 some_function// 参数列表 int, intint some_function(int, int);

如上，我们声明了一个名为 some_function 的函数，它需要接收两个 int 类型的参数，返回值类型也为 int。可以认为，这个函数将会对传入的两个整数进行一些操作，并且返回一个同样类型的结果。

实现函数：编写函数的定义

只有函数的声明（declaration）还不够，他只能让我们在调用时能够得知函数的接口类型（即接收什么数据、返回什么数据），但其缺乏具体的内部实现，也就是函数的定义（definition）。我们可以在 声明之后的其他地方 编写代码实现（implement）这个函数（也可以在另外的文件中实现，但是需要将分别编译后的文件在链接时一并给出）。

如果函数有返回值，则需要通过 return 语句，将值返回给调用方。函数一旦执行到 return 语句，则直接结束当前函数，不再执行后续的语句。

int some_function(int, int);  // 声明/* some other code here... */int some_function(int x, int y) {  // 定义  int result = 2 * x + y;  return result;  result = 3;  // 这条语句不会被执行}

如果函数不需要有返回值，则将函数的返回值类型标为 void；如果函数不需要参数，则可以将参数列表置空。同样，无返回值的函数执行到 return; 语句也会结束执行。

void saylove(){    printf("love yz\n");}

函数的调用

和变量一样，函数需要先被声明，才能使用。使用函数的行为，叫做“调用（call）”。我们可以在任何函数内部调用其他函数，包括这个函数自身。函数调用自身的行为，称为递归（recursion）。

在大多数语言中，调用函数的写法，是 函数名称加上一对括号 ()，如 yz()。如果函数需要参数，则我们将其需要的参数按顺序填写在括号中，以逗号间隔，如 yz(1, 2)。函数的调用也是一个表达式，函数的返回值 就是 表达式的值。

函数声明时候写出的参数，可以理解为在函数 当前次调用的内部 可以使用的变量，这些变量的值由调用处传入的值初始化。看下面这个例子：

void foo(int x, int y) {
  x = x * 2;
  y = y + 3;
}

/* ... */

a = 1;
b = 1;
// 调用前：a = 1, b = 1
foo(a, b);  // 调用 foo
            // 调用后：a = 1, b = 1

在上面的例子中，yz(a, b) 是一次对 foo 的调用。调用时，yz 中的 x 和 y 变量，分别由调用处 a 和 b 的值初始化。因此，在 yz 中对变量 x 和 y 的修改，并不会影响到调用处的变量的值。

如果我们需要在函数（子过程）中修改变量的值，则需要采用“传引用”的方式。

void foo(int& x, int& y) {
  x = x * 2;
  y = y + 3;
}

/* ... */

a = 1;
b = 1;
// 调用前：a = 1, b = 1
foo(a, b);  // 调用 foo
            // 调用后：a = 2, b = 4

上述代码中，我们看到函数参数列表中的“int”后面添加了一个“&（and 符号）”，这表示对于 int 类型的引用（reference）。在调用 foo 时，调用处 a 和 b 变量分别初始化了 foo 中两个对 int 类型的引用 x 和 y。在 foo 中的 x 和 y，可以理解为调用处 a 和 b 变量的“别名”，即 foo 中对 x 和 y 的操作，就是对调用处 a 和 b 的操作。

结构体

结构体（struct），可以看做是一系列称为成员元素的组合体。

可以看做是自定义的数据类型。

定义结构

为了定义结构，必须使用 struct 语句。struct 语句定义了一个包含多个成员的新的数据类型，struct 语句的格式如下：

struct tag {     member-list    member-list     member-list      ...} variable-list ;

tag 是结构体标签。

member-list 是标准的变量定义，比如 int i; 或者 float f，或者其他有效的变量定义。

variable-list 结构变量，定义在结构的末尾，最后一个分号之前，您可以指定一个或多个结构变量。下面是声明 Book 结构的方式：

struct Books{   char  title[50];   char  author[50];   char  subject[100];   int   book_id;} book;

在一般情况下，tag、member-list、variable-list 这 3 部分至少要出现 2 个。以下为实例：

//此声明声明了拥有3个成员的结构体，分别为整型的a，字符型的b和双精度的c
//同时又声明了结构体变量s1
//这个结构体并没有标明其标签
struct
{
    int a;
    char b;
    double c;
} s1;

//此声明声明了拥有3个成员的结构体，分别为整型的a，字符型的b和双精度的c
//结构体的标签被命名为SIMPLE,没有声明变量
struct SIMPLE
{
    int a;
    char b;
    double c;
};
//用SIMPLE标签的结构体，另外声明了变量t1、t2、t3
struct SIMPLE t1, t2[20], *t3;

//也可以用typedef创建新类型
typedef struct
{
    int a;
    char b;
    double c;
} Simple2;
//现在可以用Simple2作为类型声明新的结构体变量
Simple2 u1, u2[20], *u3;

结构体变量的初始化

#include <stdio.h>

struct Books
{
   char  title[50];
   char  author[50];
   char  subject[100];
   int   book_id;
} book = {"C 语言", "RUNOOB", "编程语言", 123456};

int main()
{
    printf("title : %s\nauthor: %s\nsubject: %s\nbook_id: %d\n", book.title, book.author, book.subject, book.book_id);
}
/*
title : C 语言
author: RUNOOB
subject: 编程语言
book_id: 123456
*/

访问结构成员

为了访问结构的成员，我们使用成员访问运算符（.）。成员访问运算符是结构变量名称和我们要访问的结构成员之间的一个句号。您可以使用 struct 关键字来定义结构类型的变量。下面的实例演示了结构的用法：

#include <stdio.h>#include <string.h> struct Books{   char  title[50];   char  author[50];   char  subject[100];   int   book_id;}; int main( ){   struct Books Book1;        /* 声明 Book1，类型为 Books */   struct Books Book2;        /* 声明 Book2，类型为 Books */    /* Book1 详述 */   strcpy( Book1.title, "C Programming");   strcpy( Book1.author, "Nuha Ali");    strcpy( Book1.subject, "C Programming Tutorial");   Book1.book_id = 6495407;    /* Book2 详述 */   strcpy( Book2.title, "Telecom Billing");   strcpy( Book2.author, "Zara Ali");   strcpy( Book2.subject, "Telecom Billing Tutorial");   Book2.book_id = 6495700;    /* 输出 Book1 信息 */   printf( "Book 1 title : %s\n", Book1.title);   printf( "Book 1 author : %s\n", Book1.author);   printf( "Book 1 subject : %s\n", Book1.subject);   printf( "Book 1 book_id : %d\n", Book1.book_id);    /* 输出 Book2 信息 */   printf( "Book 2 title : %s\n", Book2.title);   printf( "Book 2 author : %s\n", Book2.author);   printf( "Book 2 subject : %s\n", Book2.subject);   printf( "Book 2 book_id : %d\n", Book2.book_id);    return 0;}/*Book 1 title : C ProgrammingBook 1 author : Nuha AliBook 1 subject : C Programming TutorialBook 1 book_id : 6495407Book 2 title : Telecom BillingBook 2 author : Zara AliBook 2 subject : Telecom Billing TutorialBook 2 book_id : 6495700*/

指针

变量的地址、指针

在程序中，我们的数据都有其存储的地址。在程序每次的实际运行过程中，变量在物理内存中的存储位置不尽相同。不过，我们仍能够在编程时，通过一定的语句，来取得数据在内存中的地址。

地址也是数据。存放地址所用的变量类型有一个特殊的名字，叫做“指针变量”，有时也简称做“指针”。

地址只是一个刻度一般的数据，为了针对不同类型的数据，“指针变量”也有不同的类型，比如，可以有 int 类型的指针变量，其中存储的地址（即指针变量存储的数值）对应一块大小为 32 位的空间的起始地址；有 char 类型的指针变量，其中存储的地址对应一块 8 位的空间的起始地址。

事实上，用户也可以声明指向指针变量的指针变量。

指针的声明与使用

#include <stdio.h> int main (){    int yrh = 10;    int *p;              // 定义指针变量    p = &yrh;    printf("yrh 变量的地址： %p\n", p);   return 0;}/*yrh 变量的地址： 0x7ffeeaae08d8*/

什么是指针？

指针也就是内存地址，指针变量是用来存放内存地址的变量。就像其他变量或常量一样，您必须在使用指针存储其他变量地址之前，对其进行声明。指针变量声明的一般形式为：

type *var-name;

在这里，type 是指针的基类型，它必须是一个有效的 C 数据类型，var-name 是指针变量的名称。用来声明指针的星号 * 与乘法中使用的星号是相同的。但是，在这个语句中，星号是用来指定一个变量是指针。以下是有效的指针声明：

int    *ip;    /* 一个整型的指针 */double *dp;    /* 一个 double 型的指针 */float  *fp;    /* 一个浮点型的指针 */char   *ch;    /* 一个字符型的指针 */

所有实际数据类型，不管是整型、浮点型、字符型，还是其他的数据类型，对应指针的值的类型都是一样的，都是一个代表内存地址的长的十六进制数。

不同数据类型的指针之间唯一的不同是，指针所指向的变量或常量的数据类型不同。

如何使用指针？

使用指针时会频繁进行以下几个操作：定义一个指针变量、把变量地址赋值给指针、访问指针变量中可用地址的值。这些是通过使用一元运算符 * 来返回位于操作数所指定地址的变量的值。下面的实例涉及到了这些操作：

#include <stdio.h> int main (){   int  var = 20;   /* 实际变量的声明 */   int  *ip;        /* 指针变量的声明 */    ip = &var;  /* 在指针变量中存储 var 的地址 */    printf("var 变量的地址: %p\n", &var  );    /* 在指针变量中存储的地址 */   printf("ip 变量存储的地址: %p\n", ip );    /* 使用指针访问值 */   printf("*ip 变量的值: %d\n", *ip );    return 0;}/*var 变量的地址: 0x7ffeeef168d8ip 变量存储的地址: 0x7ffeeef168d8*ip 变量的值: 20*/

C 中的 NULL 指针

在变量声明的时候，如果没有确切的地址可以赋值，为指针变量赋一个 NULL 值是一个良好的编程习惯。赋为 NULL 值的指针被称为空指针。

NULL 指针是一个定义在标准库中的值为零的常量

#include <stdio.h> int main (){   int  *ptr = NULL;    printf("ptr 的地址是 %p\n", ptr  );    return 0;}/*ptr 的地址是 0x0*/

在大多数的操作系统上，程序不允许访问地址为 0 的内存，因为该内存是操作系统保留的。然而，内存地址 0 有特别重要的意义，它表明该指针不指向一个可访问的内存位置。但按照惯例，如果指针包含空值（零值），则假定它不指向任何东西。

如需检查一个空指针，可以使用 if 语句，如下所示：

if(ptr)     /* 如果 p 非空，则完成 */if(!ptr)    /* 如果 p 为空，则完成 */

指针的算术运算

C 指针是一个用数值表示的地址。因此，您可以对指针执行算术运算。可以对指针进行四种算术运算：++、--、+、-。

假设 ptr 是一个指向地址 1000 的整型指针，是一个 32 位的整数，让我们对该指针执行下列的算术运算：

ptr++

在执行完上述的运算之后，ptr 将指向位置 1004，因为 ptr 每增加一次，它都将指向下一个整数位置，即当前位置往后移 4 字节。这个运算会在不影响内存位置中实际值的情况下，移动指针到下一个内存位置。如果 ptr 指向一个地址为 1000 的字符，上面的运算会导致指针指向位置 1001，因为下一个字符位置是在 1001。

指针的每一次递增，它其实会指向下一个元素的存储单元。
指针的每一次递减，它都会指向前一个元素的存储单元。
指针在递增和递减时跳跃的字节数取决于指针所指向变量数据类型长度，比如 int 就是 4 个字节。

递增一个指针

#include <stdio.h> const int MAX = 3; int main (){   int  var[] = {10, 100, 200};   int  i, *ptr;    /* 指针中的数组地址 */   ptr = var;   for ( i = 0; i < MAX; i++)   {       printf("存储地址：var[%d] = %p\n", i, ptr );      printf("存储值：var[%d] = %d\n", i, *ptr );       /* 指向下一个位置 */      ptr++;   }   return 0;}/*存储地址：var[0] = e4a298cc存储值：var[0] = 10存储地址：var[1] = e4a298d0存储值：var[1] = 100存储地址：var[2] = e4a298d4存储值：var[2] = 200*/

递减一个指针

#include <stdio.h> const int MAX = 3; int main (){   int  var[] = {10, 100, 200};   int  i, *ptr;    /* 指针中最后一个元素的地址 */   ptr = &var[MAX-1];   for ( i = MAX; i > 0; i--)   {       printf("存储地址：var[%d] = %p\n", i-1, ptr );      printf("存储值：var[%d] = %d\n", i-1, *ptr );       /* 指向下一个位置 */      ptr--;   }   return 0;}/*存储地址：var[2] = 518a0ae4存储值：var[2] = 200存储地址：var[1] = 518a0ae0存储值：var[1] = 100存储地址：var[0] = 518a0adc存储值：var[0] = 10*/

指针的比较

指针可以用关系运算符进行比较，如 ==、< 和 >。如果 p1 和 p2 指向两个相关的变量，比如同一个数组中的不同元素，则可对 p1 和 p2 进行大小比较。

下面的程序修改了上面的实例，只要变量指针所指向的地址小于或等于数组的最后一个元素的地址 &var[MAX - 1]，则把变量指针进行递增：

#include <stdio.h> const int MAX = 3; int main (){   int  var[] = {10, 100, 200};   int  i, *ptr;    /* 指针中第一个元素的地址 */   ptr = var;   i = 0;   while ( ptr <= &var[MAX - 1] )   {       printf("存储地址：var[%d] = %p\n", i, ptr );      printf("存储值：var[%d] = %d\n", i, *ptr );       /* 指向上一个位置 */      ptr++;      i++;   }   return 0;}/*存储地址：var[0] = 0x7ffeee2368cc存储值：var[0] = 10存储地址：var[1] = 0x7ffeee2368d0存储值：var[1] = 100存储地址：var[2] = 0x7ffeee2368d4存储值：var[2] = 200*/

指针数组

我们想要让数组存储指向 int 或 char 或其他数据类型的指针。下面是一个指向整数的指针数组的声明：

int *ptr[MAX];

在这里，把 ptr 声明为一个数组，由 MAX 个整数指针组成。因此，ptr 中的每个元素，都是一个指向 int 值的指针。下面的实例用到了三个整数，它们将存储在一个指针数组中，如下所示：

#include <stdio.h> const int MAX = 3; int main (){   int  var[] = {10, 100, 200};   int i, *ptr[MAX];    for ( i = 0; i < MAX; i++)   {      ptr[i] = &var[i]; /* 赋值为整数的地址 */   }   for ( i = 0; i < MAX; i++)   {      printf("Value of var[%d] = %d\n", i, *ptr[i] );   }   return 0;}/*Value of var[0] = 10Value of var[1] = 100Value of var[2] = 200*/

可以用一个指向字符的指针数组来存储一个字符串列表，如下：

#include <stdio.h> const int MAX = 4; int main (){   const char *names[] = {                   "yrh",                   "love",                   "yz",                   "!",   };   int i = 0;    for ( i = 0; i < MAX; i++)   {      printf("Value of names[%d] = %s\n", i, names[i] );   }   return 0;}/*Value of names[0] = yrhValue of names[1] = loveValue of names[2] = yzValue of names[3] = !*/

指向指针的指针

指向指针的指针是一种多级间接寻址的形式，或者说是一个指针链。通常，一个指针包含一个变量的地址。当我们定义一个指向指针的指针时，第一个指针包含了第二个指针的地址，第二个指针指向包含实际值的位置。

一个指向指针的指针变量必须如下声明，即在变量名前放置两个星号。例如，下面声明了一个指向 int 类型指针的指针：

int **var;

当一个目标值被一个指针间接指向到另一个指针时，访问这个值需要使用两个星号运算符，如下面实例所示：

#include <stdio.h> int main (){   int  V;   int  *Pt1;   int  **Pt2;    V = 100;    /* 获取 V 的地址 */   Pt1 = &V;    /* 使用运算符 & 获取 Pt1 的地址 */   Pt2 = &Pt1;    /* 使用 pptr 获取值 */   printf("var = %d\n", V );   printf("Pt1 = %p\n", Pt1 );   printf("*Pt1 = %d\n", *Pt1 );    printf("Pt2 = %p\n", Pt2 );   printf("**Pt2 = %d\n", **Pt2);    return 0;}/*var = 100Pt1 = 0x7ffee2d5e8d8*Pt1 = 100Pt2 = 0x7ffee2d5e8d0**Pt2 = 100*/

传递指针给函数

C 语言允许传递指针给函数，只需要简单地声明函数参数为指针类型即可。

#include <stdio.h>
#include <time.h>

void getSeconds(unsigned long *par);

int main ()
{
   unsigned long sec;


   getSeconds( &sec );

   /* 输出实际值 */
   printf("Number of seconds: %ld\n", sec );

   return 0;
}

void getSeconds(unsigned long *par)
{
   /* 获取当前的秒数 */
   *par = time( NULL );
   return;
}
/*
Number of seconds :1294450468
*/

能接受指针作为参数的函数，也能接受数组作为参数，如下所示：

#include <stdio.h>

/* 函数声明 */
double getAverage(int *arr, int size);

int main ()
{
   /* 带有 5 个元素的整型数组  */
   int balance[5] = {1000, 2, 3, 17, 50};
   double avg;

   /* 传递一个指向数组的指针作为参数 */
   avg = getAverage( balance, 5 ) ;

   /* 输出返回值  */
   printf("Average value is: %f\n", avg );

   return 0;
}

double getAverage(int *arr, int size)
{
  int    i, sum = 0;
  double avg;

  for (i = 0; i < size; ++i)
  {
    sum += arr[i];
  }

  avg = (double)sum / size;

  return avg;
}
/*
Average value is: 214.40000
*/

从函数返回指针

C 允许从函数返回指针。为了做到这点，必须声明一个返回指针的函数，如下所示：

int * myFunction(){...}

另外，C 语言不支持在调用函数时返回局部变量的地址，除非定义局部变量为 static 变量。

它会生成 10 个随机数，并使用表示指针的数组名（即第一个数组元素的地址）来返回它们

#include <stdio.h>
#include <time.h>
#include <stdlib.h>

/* 要生成和返回随机数的函数 */
int * getRandom( )
{
   static int  r[10];
   int i;

   /* 设置种子 */
   srand( (unsigned)time( NULL ) );
   for ( i = 0; i < 10; ++i)
   {
      r[i] = rand();
      printf("%d\n", r[i] );
   }

   return r;
}

/* 要调用上面定义函数的主函数 */
int main ()
{
   /* 一个指向整数的指针 */
   int *p;
   int i;

   p = getRandom();
   for ( i = 0; i < 10; i++ )
   {
       printf("*(p + [%d]) : %d\n", i, *(p + i) );
   }

   return 0;
}
/*
1523198053
1187214107
1108300978
430494959
1421301276
930971084
123250484
106932140
1604461820
149169022
*(p + [0]) : 1523198053
*(p + [1]) : 1187214107
*(p + [2]) : 1108300978
*(p + [3]) : 430494959
*(p + [4]) : 1421301276
*(p + [5]) : 930971084
*(p + [6]) : 123250484
*(p + [7]) : 106932140
*(p + [8]) : 1604461820
*(p + [9]) : 149169022
*/

字符串

定义

在 C 语言中，字符串实际上是使用 null 字符 \0 终止的一维字符数组。因此，一个以 null 结尾的字符串，包含了组成字符串的字符。

char yrh[7] = {'l','o','v','e','y','z','\0'};

依据数组初始化规则，可以把上面的语句写成以下语句：

char yrh[] = "loveyz";

操作字符串的函数:

#include <string.h>
| 序号 | 函数 & 目的 |
| :--- | :----------------------------------------------------------------------------------------------------- |
| 1    | **strcpy(s1, s2);** 复制字符串 s2 到字符串 s1。                                                        |
| 2    | **strcat(s1, s2);** 连接字符串 s2 到字符串 s1 的末尾。                                                 |
| 3    | **strlen(s1);** 返回字符串 s1 的长度。                                                                 |
| 4    | **strcmp(s1, s2);** 如果 s1 和 s2 是相同的，则返回 0；如果 s1 < s2 则返回小于 0；如果 s1 > s2 则返回大于 0。 |
| 5    | **strchr(s1, ch);** 返回一个指针，指向字符串 s1 中字符 ch 的第一次出现的位置。                         |
| 6    | **strstr(s1, s2);** 返回一个指针，指向字符串 s1 中字符串 s2 的第一次出现的位置。                       |

#include <stdio.h>
#include <string.h>

int main ()
{
   char str1[14] = "yrh";
   char str2[14] = "yz";
   char str3[14];
   int  len ;

   /* 复制 str1 到 str3 */
   strcpy(str3, str1);
   printf("strcpy( str3, str1) :  %s\n", str3 );

   /* 连接 str1 和 str2 */
   strcat( str1, str2);
   printf("strcat( str1, str2):   %s\n", str1 );

   /* 连接后，str1 的总长度 */
   len = strlen(str1);
   printf("strlen(str1) :  %d\n", len );

   return 0;
}

排序算法

冒泡排序

#include <stdio.h>
void bubble_sort(int arr[], int len) {
    int i, j, temp;
    for (i = 0; i < len - 1; i++)
        for (j = 0; j < len - 1 - i; j++)
            if (arr[j] > arr[j + 1]) {
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
}
int main() {
    int arr[] = { 22, 34, 3, 32, 82, 55, 89, 50, 37, 5, 64, 35, 9, 70 };
    int len = (int) sizeof(arr) / sizeof(*arr);
    bubble_sort(arr, len);
    int i;
    for (i = 0; i < len; i++)
        printf("%d ", arr[i]);
    return 0;
}

选择排序

void selection_sort(int a[], int len)
{
    int i,j,temp;

    for (i = 0 ; i < len - 1 ; i++)
    {
        int min = i;                  // 记录最小值，第一个元素默认最小
        for (j = i + 1; j < len; j++)     // 访问未排序的元素
        {
            if (a[j] < a[min])    // 找到目前最小值
            {
                min = j;    // 记录最小值
            }
        }
        if(min != i)
        {
            temp=a[min];  // 交换两个变量
            a[min]=a[i];
            a[i]=temp;
        }
        /* swap(&a[min], &a[i]);  */   // 使用自定义函数交換
    }
}

/*
void swap(int *a,int *b) // 交换两个变量
{
    int temp = *a;
    *a = *b;
    *b = temp;
}
*/

插入排序

void insertion_sort(int arr[], int len){
    int i,j,temp;
    for (i=1;i<len;i++){
            temp = arr[i];
            for (j=i;j>0 && arr[j-1]>temp;j--)
                    arr[j] = arr[j-1];
            arr[j] = temp;
    }
}

通过 webRTC 可以绕过获取真实IP