golang--數據類型與存儲

在 Go 語言中，理解值類型（value types）和引用類型（reference types）的區別對于編寫高效、正確的代碼至關重要。以下是主要的區別點和需要注意的特殊情況：

一、值類型（Value Types）

包含的類型：

  • 基本數據類型（bool, int, float, complex, string 等）
  • 數組（array）
  • 結構體（struct）

核心特點：

1. 直接存儲值

a := 42
b := a  // 創建 a 的副本（值復制）
b = 10  // 修改 b 不影響 a
fmt.Println(a) // 42

2. 傳參時復制整個值

func modify(arr [3]int) {arr[0] = 100
}
original := [3]int{1, 2, 3}
modify(original)
fmt.Println(original) // [1 2 3]（未改變）

內存存儲

通常分配在棧上（小對象），但可能逃逸到堆（如函數返回局部變量地址時）。

類型存儲方式大小特點
bool直接存儲（true=1，false=0）1字節零值=false
整數類型直接存儲二進制值int8/16/32/64支持位操作
浮點數IEEE-754 標準float32(4B)/64(8B)精確計算需用 math/big
complex實部+虛部存儲8/16字節complex128 精度更高
array連續內存塊len*元素大小長度固定，類型簽名包含長度

示例：

// 數組存儲示例
arr := [3]int{1, 2, 3}
// 內存布局：[0x01, 0x00, 0x00, 0x00, 0x02, ...] (小端序)

3. 內存分配在棧上（小對象）

  • 小對象（如結構體）通常在棧上分配，速度更快

4. string 的特殊性

  • 共享只讀
   s1 := "hello"s2 := s1 // 雖然 string 是值類型，但底層共享只讀字節數組// 修改會觸發新內存分配（不可變性）
  • 底層字節數組不可變：
s := "hello"
// s[0] = 'H' // 編譯錯誤（禁止修改）
s2 := s          // 復制描述符（8+8=16字節），共享底層數據
s3 := s + "world" // 新建底層數組（復制+追加）
  • 子串零成本??：截取子串不需要復制數據
    截取子字符串（如s[i:j]）時，會創建一個新的字符串頭，其中Data指向原字符串的相應位置（即原起始地址加上偏移量i），長度設置為j-i。因此，子字符串和原字符串共享一部分底層數組。

5. 比較支持

type Point struct{ X, Y int }
p1 := Point{1, 2}
p2 := Point{1, 2}
fmt.Println(p1 == p2) // true（可比較）

String

Unicode庫，判斷字符的類型


其中 v 代表字符）：
判斷是否為字母： unicode.IsLetter(v)
判斷是否為十進制數字： unicode.IsDigit(v)
判斷是否為數字： unicode.IsNumber(v)
判斷是否為空白符號： unicode.IsSpace(v)
判斷是否為Unicode標點字符 :unicode.IsPunct(v)

取出一個字符串中的字符串和數值字符串
得到map[ddgm:[495 468] fdfsf:[123.4 1.2 11] dg:[49151]]

str:="fdfsf,123.4,1.2,11,dg,49151,ddgm,495,468"
istMap :=  make(map[string][]string)
start := 0var key stringvar value []stringvar tmp stringvar tmpArr []stringfor index, v := range instruction {if string(v) == "," && index != len(instruction)-1 && unicode.IsLetter(rune(instruction[index+1])) { //標點和結束tmp = instruction[start:index]tmpArr = strings.Split(tmp, ",")key = tmpArr[0]value = tmpArr[1:]istMap[key] = valuestart = index + 1}if index == len(str)-1 { //數值tmp = str[start : index+1]tmpArr = strings.Split(tmp, ",")key = tmpArr[0]value = tmpArr[1:]istMap[key] = valuestart = index + 1}}

只讀共享

	s := "abcdef"s1 := sfmt.Printf("s指針地址: %p\n", &s)fmt.Printf("s1指針地址: %p\n", &s1)fmt.Printf("s底層數據地址: %p\n", unsafe.StringData(s))fmt.Printf("s1底層數據地址: %p\n", unsafe.StringData(s1))//（只讀共享）// 修改操作會觸發新分配s1 += " world"fmt.Printf("s指針地址: %p\n", &s)fmt.Printf("s1指針地址: %p\n", &s1)fmt.Printf("s底層數據地址: %p\n", unsafe.StringData(s))fmt.Printf("s1底層數據地址: %p\n", unsafe.StringData(s1))
/*
s指針地址: 0xc00023aab0
s1指針地址: 0xc00023aac0
s底層數據地址: 0x184b115
s1底層數據地址: 0x184b115
s指針地址: 0xc00023aab0
s1指針地址: 0xc00023aac0
s底層數據地址: 0x184b115
s1底層數據地址: 0xc000213120
*/

如何實現的只讀特性？

底層數據結構

字符串在運行時表示為：

type StringHeader struct {Data uintptr // 指向底層字節數組的指針Len  int     // 字符串長度
}
  • Data指向只讀內存區域
  • 無修改字符串內容的操作接口
編譯器級別的保護

編譯錯誤

s := "hello"
s[0] = 'H' // 編譯錯誤: cannot assign to s[0]
運行時保護

運行時機制

  1. 只讀內存段
  • 字符串字面量存儲在二進制文件的.rodata(只讀數據段)
  • 程序加載時，操作系統將其映射到只讀內存頁
  1. 寫保護內存頁
    現代操作系統對只讀內存頁設置寫保護：
內存頁權限：
.rodata 段: R-- (只讀不可寫)
.data 段: RW- (可讀寫)
.text 段: R-X (可讀可執行)
  1. 硬件級保護
  • CPU 內存管理單元(MMU)攔截非法寫操作
  • 觸發操作系統級保護異常(SIGSEGV)

二、引用類型（Reference Types）

包含的類型：

  • 切片（slice）
  • 映射（map）
  • 通道（channel）
  • 函數（func）
  • 指針（pointer）
  • 接口（interface）

核心特點：

  1. 存儲的是引用（指針）

    m1 := map[string]int{"a": 1}
m2 := m1  // 復制引用（共享底層數據）
m2["a"] = 100
fmt.Println(m1["a"]) // 100（值被修改）

  2. 零值為 nil

    var s []int        // nil slice
var m map[string]int // nil map
// 操作 nil 引用會導致運行時錯誤

  3. 不可直接比較

    s1 := []int{1,2}
s2 := []int{1,2}
// fmt.Println(s1 == s2) // 編譯錯誤（slice 不可比較）
// 只能與 nil 比較: fmt.Println(s1 == nil)

  4. 函數傳遞效率高

    func process(slice []int) {// 只傳遞 24 字節的切片頭（ptr+len+cap）
}
data := make([]int, 1000000) // 底層數組很大
process(data)               // 高效傳遞

  5. 共享底層數據風險

    original := []int{1,2,3,4}
sub := original[:2] // 共享同一個底層數組
sub[0] = 99
fmt.Println(original[0]) // 99（意外修改！）

內存存儲

類型底層結構描述符大小特點
slice{ptr *T, len int, cap int}24字節cap ≥ len，可動態增長
map指向 runtime.hmap 的指針8字節哈希桶+溢出鏈
chan指向 runtime.hchan 的指針8字節環形隊列+同步原語
func函數入口地址指針8字節閉包捕獲外部變量
pointer目標內存地址8字節可指向任意類型
interface{_type *rtype, data unsafe.Pointer}16字節動態分發基礎

需要特別注意的場景

1. 切片擴容陷阱

s := make([]int, 2, 4) // [0,0] 容量4
s1 := s[:2]           // 共享底層數組s = append(s, 5)     // 容量夠，未擴容
s1[0] = 1            // 修改共享數組
fmt.Println(s[0])    // 1（被修改）s = append(s, 6,7)   // 超過容量，新建數組
s1[0] = 2           // 不再影響 s
fmt.Println(s[0])    // 1（未改變）

2. Map 并發訪問危險

m := make(map[int]int)
go func() {for { m[1]++ } // 并發寫
}()
go func() {for { _ = m[1] } // 并發讀
}()
// 可能觸發 fatal error: concurrent map read and map write

解決方案：

  • 使用 sync.Mutex 或 sync.RWMutex
  • 使用 sync.Map（Go 1.9+）

3. 接口的特殊行為

var w io.Writer = os.Stdout
w.Write([]byte("hello")) // 正確var w2 io.Writer
// w2.Write(...)  // 運行時 panic: nil pointer

關鍵點：

  • 接口變量存儲 (type, value) 對
  • 值為 nil 但類型非空的接口不等于 nil：
    var buf *bytes.Buffer
var w io.Writer = buf
fmt.Println(w == nil) // false！(類型為 *bytes.Buffer)

4. 指針接收者與方法

type Counter struct{ n int }func (c *Counter) Inc() { c.n++ } // 指針接收者c := Counter{}
c.Inc()    // 自動轉換為 (&c).Inc()
fmt.Println(c.n) // 1

規則：

  • 值類型可調用指針接收者方法（Go 自動取地址）
  • 指針類型可調用值接收者方法（Go 自動解引用）

性能優化建議

  1. 大結構體用指針傳遞

    type LargeStruct struct { data [1024]byte }// 避免復制開銷
func (s *LargeStruct) Process() {}

  2. 避免不必要的堆分配

    // 不佳：返回指針導致堆分配
func newPoint() *Point { return &Point{x: 1} }// 推薦：返回值（可能棧分配）
func newPoint() Point { return Point{x: 1} }

  3. 預分配切片/映射容量

    // 避免頻繁擴容
users := make([]User, 0, 1000)
cache := make(map[string]int, 100)

特殊類型指南

類型值/引用比較復制行為注意要點
數組值?深拷貝傳參效率低
切片引用?復制引用小心共享數據和擴容
Map引用?復制引用非并發安全，需加鎖
通道引用?*復制引用比較相同通道對象
接口引用?復制描述符有運行時開銷
函數引用?復制函數指針可作一等公民使用
字符串值?復制描述符底層數據只讀共享

(*) 通道可比較：相同通道實例比較為 true

總結關鍵點

  1. 修改行為：引用類型會修改所有引用同一數據的變量
  2. 零值處理：引用類型零值為 nil，需顯式初始化
  3. 并發安全：基本值類型原子操作安全，引用類型需要同步
  4. 性能取舍：
    • 小對象：優先用值類型（棧分配）
    • 大對象：用指針或引用類型（避免復制）
  5. 比較限制：切片、map、函數等不可比較
  6. 接口陷阱：nil 接口 != nil 具體值

理解這些差異可以幫助你避免常見陷阱（如意外數據共享、nil指針panic）并編寫更高效的Go代碼。

三、各個類型的指針操作

1. 基礎指針操作

var a int = 42
p := &a  // 獲取地址// 解引用操作
*p = 100  // a 變為 100
fmt.Println(a == *p) // true

2. 結構體指針優化

type Point struct{ X, Y float64 }// 直接通過指針訪問字段（編譯器自動優化）
p := &Point{1, 2}
p.Y = 3 // 等價于 (*p).Y = 3

3. 切片指針操作

data := []int{1, 2, 3}
ptr := &data[0]   // 獲取首元素地址
*ptr = 100        // data[0] = 100// 危險操作：訪問越界元素
// badPtr := &data[5]  // 編譯通過但運行時 panic

4. unsafe 高級指針操作

import "unsafe"type Secret struct {id   int32flag uint16
}s := Secret{1024, 0xABCD}
ptr := unsafe.Pointer(&s)// 訪問結構體內部字段
idPtr := (*int32)(ptr)          // 獲取 id 字段指針
flagPtr := (*uint16)(unsafe.Pointer(uintptr(ptr) + unsafe.Offsetof(s.flag)))fmt.Println(*idPtr)   // 1024
fmt.Printf("%X", *flagPtr) // ABCD

四、各類型特殊注意事項

1. 字符串：只讀字節序列

s := "hello"
// s[0] = 'H' // 編譯錯誤：不可修改// 安全轉換：string ? []byte
bytes := []byte(s)  // 復制數據創建新切片
str := string(bytes) // 同樣復制數據

2. 切片：三大核心陷阱

陷阱 1：共享底層數組

original := []int{1,2,3,4,5}
sub := original[1:3] // 共享底層數組sub[0] = 100 // 修改影響 original[1]
fmt.Println(original) // [1,100,3,4,5]

陷阱 2：append 自動擴容

s := make([]int, 2, 3) // len=2, cap=3
s1 := append(s, 1)    // 共用底層數組
s2 := append(s, 2)    // 仍然共用到 cap=3s2[0] = 100           // 意外修改 s 和 s1
fmt.Println(s[0])     // 100（預期為 0）

陷阱 3：空切片 vs nil 切片

var nilSlice []int      // nil，與 nil 相等
emptySlice := []int{}   // 非 nil，已分配描述符fmt.Println(nilSlice == nil)   // true
fmt.Println(emptySlice == nil)  // false

3. Map：特殊的引用類型

m := make(map[string]int)
m["a"] = 1// 錯誤：禁止取元素地址
// p := &m["a"]  // 編譯錯誤：無法獲取地址// 正確訪問方式
val, exists := m["a"]

4. 接口：雙重指針設計

var w io.Writer
w = os.Stdout     // 存儲 {*os.File類型信息, *os.File值指針}// nil 接口 != nil 具體值
var buf *bytes.Buffer
w = buf            // w != nil（類型信息非空）
if w == nil {      // false /* ... */ 
}

五、高效內存操作指南

1. 內存復用技巧

// 重用切片內存（避免重復分配）
pool := make([]*Object, 0, 100)func getObject() *Object {if len(pool) > 0 {obj := pool[len(pool)-1]pool = pool[:len(pool)-1]return obj}return &Object{}
}

2. 零拷貝轉換（unsafe 實現）

// string → []byte（零拷貝）
func stringToBytes(s string) []byte {return *(*[]byte)(unsafe.Pointer(&struct {s stringc int}{s, len(s)},))
}
// 注意：結果切片只讀！

3. 避免意外內存泄漏

func process() {bigData := make([]byte, 10<<20) // 10MB// 切片截取導致大內存無法回收smallPart := bigData[:10]// 解決方案：復制需要的數據result := make([]byte, 10)copy(result, bigData[:10])
} // 整個 10MB 可被回收

六、指針操作安全規范

1. 禁止指針運算（除 unsafe）

   arr := [3]int{1,2,3}p := &arr[0]// p++ // 禁止：Go 不支持指針算術

2. 內存對齊檢查

   type BadLayout struct {a bool    // 1字節b int64   // 8字節 (需要7字節填充)}             // 總大小16字節而非9字節

3. cgo 指針安全

   /*#include <stdlib.h>*/import "C"import "unsafe"func copyToC(data []byte) {cptr := C.malloc(C.size_t(len(data)))defer C.free(cptr)// 通過unsafe轉換C.memcpy(cptr, unsafe.Pointer(&data[0]), C.size_t(len(data)))}

4. 引用類型禁止取元素地址

m := map[int]string{1: "one"}
// 以下操作非法！因為map元素可能被重新散列遷移
// p := &m[1]

5. 切片的安全操作

s := []int{1,2,3}
first := &s[0] // 允許取元素地址
*first = 100   // 合法操作（底層數組穩定）

七、性能優化對照表

操作推薦方式避免方式性能提升
大結構體傳參func(p *Struct)func(s Struct)8x+
小結構體傳參func(s Struct)func(p *Struct)15-20%
大切片傳遞func(s []T)func(arr [10000]T)10000x
臨時對象創建sync.Pool重復 new3-5x
字符串拼接strings.Builder+ 操作符10x+
Map 初始化m := make(map[K]V, hint)無預設容量2-3x

存儲，指針操作總結

  1. 存儲本質：

    • 值類型：直接存儲數據
    • 引用類型：存儲描述符（指針+元數據）
    • 特殊類型：字符串只讀、接口雙層指針

  2. 指針安全：

    • 常規代碼避免使用 unsafe
    • 禁止取 map 元素地址
    • 注意切片共享的陷阱

  3. 性能關鍵：

    • 大對象用指針傳遞
    • 預分配切片/map容量
    • 避免不必要的數據復制

  4. 內存管理：

    • 理解逃逸分析機制
    • 復用內存（sync.Pool）
    • 避免因切片截取導致內存泄漏

八、不同類型的重點

切片擴容

Go語言在runtime/slice.go中的實現（go版本1.24），切片擴容的規則可以總結如下：

  1. 核心函數growslice
func growslice(oldPtr unsafe.Pointer, newLen, oldCap, num int, et *_type) slice
  • oldPtr: 原切片底層數組指針
  • newLen: 擴容后的新長度
  • oldCap: 原切片容量
  • num: 新增元素數量
  • et: 元素類型信息
  1. 切片(slice)擴容容量計算的函數
// nextslicecap computes the next appropriate slice length.
func nextslicecap(newLen, oldCap int) int {//首先檢查新長度是否超過舊容量的2倍，如果是則直接返回新長度newcap := oldCapdoublecap := newcap + newcapif newLen > doublecap {return newLen}
//對于容量小于256的小切片，采用雙倍擴容策略const threshold = 256if oldCap < threshold {return doublecap}/*對于大切片，采用平滑過渡策略：
初始增長因子約為1.25倍
通過位運算>>2實現快速除以4
循環直到找到足夠大的容量
*/for {// Transition from growing 2x for small slices// to growing 1.25x for large slices. This formula// gives a smooth-ish transition between the two.newcap += (newcap + 3*threshold) >> 2// We need to check `newcap >= newLen` and whether `newcap` overflowed.// newLen is guaranteed to be larger than zero, hence// when newcap overflows then `uint(newcap) > uint(newLen)`.// This allows to check for both with the same comparison.if uint(newcap) >= uint(newLen) {break}}// Set newcap to the requested cap when// the newcap calculation overflowed.//如果計算過程中出現溢出(負數)，則直接返回新長度if newcap <= 0 {return newLen}return newcap
}

擴容策略：

  1. 首先檢查新長度是否超過舊容量的2倍，如果是則直接返回新長度
  2. 對于容量小于256的小切片，采用雙倍擴容策略
  3. 對于大切片，采用平滑過渡策略：
  • 初始增長因子約為1.25倍
  • 通過位運算>>2實現快速除以4
  • 循環直到找到足夠大的容量
  1. 如果計算過程中出現溢出(負數)，則直接返回新長度

本文來自互聯網用戶投稿，該文觀點僅代表作者本人，不代表本站立場。本站僅提供信息存儲空間服務，不擁有所有權，不承擔相關法律責任。
如若轉載，請注明出處：http://www.pswp.cn/news/910237.shtml
繁體地址，請注明出處：http://hk.pswp.cn/news/910237.shtml
英文地址，請注明出處：http://en.pswp.cn/news/910237.shtml

如若內容造成侵權/違法違規/事實不符，請聯系多彩編程網進行投訴反饋email:809451989@qq.com，一經查實，立即刪除！

相關文章

uniapp——輪播圖、產品列表輪播、上一頁、下一頁、一屏三張圖

uniapp——輪播圖、產品列表輪播、上一頁、下一頁、一屏三張圖

案例展示 組件封裝 <template><view><view class="showSwiperBox"><view class="topSwiper"><swiper class="swiper" :autoplay="autoplay" interval="5000" :previous-margin="margin&qu…
閱讀更多...
用Python實現安全封裝EXE文件加密保護工具

用Python實現安全封裝EXE文件加密保護工具

一、概述 這個Python腳本實現了一個強大的EXE文件加密保護工具，它能夠將任何Windows可執行文件封裝到一個帶密碼保護的GUI程序中。核心功能包括： 使用AES-256加密算法保護原始EXE文件 創建美觀的密碼驗證界面 支持自定義程序圖標 自動處理PyInstaller打包過程 修復Tkinter在…
閱讀更多...
vue3監聽屬性watch和watchEffect的詳解

vue3監聽屬性watch和watchEffect的詳解

文章目錄 1. 前言2. 常規用法3. 監聽對象和route變化4. 使用場景4.1 即時表單驗證4.2 搜索聯想功能4.3 數據變化聯動處理 5. watchEffect詳解5-1 基本概念5-2 核心用法基礎示例&#xff1a;自動響應依賴變化處理異步副作用停止監聽與清理副作用 5-3 高級場景應用監聽多個響應式…
閱讀更多...
Spring IoC核心實現揭秘

Spring IoC核心實現揭秘

Spring IoC（控制反轉）的實現機制是Spring框架的核心，其本質是將對象的創建、依賴管理和生命周期控制權從應用程序代碼轉移到容器中。以下是其核心實現機制： ?? 一、核心實現步驟 配置元數據加載 容器啟動時讀取XML/注解/Java配置類，解析為BeanDefinition對象（包含類名、…
閱讀更多...
Solidity內部合約創建全解析：解鎖Web3開發新姿勢

Solidity內部合約創建全解析：解鎖Web3開發新姿勢

合約創建基礎 new 關鍵字創建合約 在 Solidity 中&#xff0c;new關鍵字是創建合約實例的最基本方式&#xff0c;它就像是一個 “魔法鑰匙”&#xff0c;能夠在以太坊區塊鏈上生成一個全新的合約實例。使用new關鍵字創建合約的過程非常直觀&#xff0c;就像我們在其他編程語言…
閱讀更多...
OCR大模型，破解金融文檔處理困境，從文字識別到文字理解

OCR大模型，破解金融文檔處理困境，從文字識別到文字理解

金融機構在日常運營中處理海量文檔。這些文檔類型多樣&#xff0c;格式復雜&#xff0c;是業務運營的基礎。如何高效、準確地處理這些文檔&#xff0c;直接影響機構的運營效率與風險控制水平。新一代的OCR大模型技術為此提供了有效的解決方案。它提升了文檔處理的自動化程度與數…
閱讀更多...
2025.6.21筆記（2）

2025.6.21筆記（2）

1.編寫一個程序&#xff0c;輸入一個整數&#xff0c;判斷它是奇數還是偶數 解題思路&#xff1a; 1.因為要判斷輸入的數是奇數還是偶數&#xff0c;所以要用到if判斷 2.判讀奇偶數&#xff1a;如果這個數%20&#xff0c;則它為偶數&#xff0c;如果這個數%2!0&#xff0c;則…
閱讀更多...
【Ambari3.0.0 部署】Step7—Mariadb初始化-適用于el8

【Ambari3.0.0 部署】Step7—Mariadb初始化-適用于el8

如果有其他系統部署需求可以參考原文 https://doc.janettr.com/install/manual/ MariaDB 10 是 Ambari 及大數據平臺的常見數據庫方案。本文適配 Rocky Linux 8.10&#xff0c;涵蓋 MariaDB 10.11 推薦安裝、YUM 源配置、參數優化、初始化和安全設置&#xff0c;幫助你一步到位…
閱讀更多...
SpringBoot電腦商城項目--刪除收獲地址+熱銷排行

SpringBoot電腦商城項目--刪除收獲地址+熱銷排行

刪除收獲地址 1 刪除收獲地址-持久層 1.1 規劃sql語句 在刪除操作之前判斷該數據是否存在&#xff0c;判斷該條地址的歸屬是否是當前的用戶執行刪除收貨地址的操作 delete from t_address where aid? 如果用戶刪除的時默認地址&#xff0c;將剩下地址的某一條作為默認收貨地…
閱讀更多...
MIMIC-III 數據集文件簡介

MIMIC-III 數據集文件簡介

文件簡介&#xff1a; 共26個文件 admissions.csv 患者入院信息&#xff08;入院時間、出院時間、入院類型、科室等&#xff09;。 callout.csv ICU 外科室請求 ICU 會診的呼叫記錄。 caregivers.csv 護理患者的醫護人員信息&#xff08;身份、角色等&#xff09;。…
閱讀更多...
UL/CE雙認證！光寶MOC3052-A雙向可控硅輸出光耦 智能家居/工業控制必備！

UL/CE雙認證！光寶MOC3052-A雙向可控硅輸出光耦 智能家居/工業控制必備！

光寶MOC3052-A雙向可控硅輸出光耦詳解 1. 產品定位 MOC3052-A 是光寶科技&#xff08;Lite-On&#xff09;推出的 雙向可控硅驅動光耦&#xff0c;屬于光電隔離型半導體器件&#xff0c;主要用于交流負載的隔離控制&#xff0c;實現低壓控制電路&#xff08;如MCU&#xff09;…
閱讀更多...
讓沒有小窗播放的視頻網站的視頻小窗播放

讓沒有小窗播放的視頻網站的視頻小窗播放

讓沒有小窗播放的視頻網站的視頻小窗播放 // 視頻小窗播放控制臺腳本 // 將此代碼復制到瀏覽器控制臺運行 // 運行后&#xff0c;頁面中的視頻將添加小窗播放功能(function() {// 獲取頁面中的所有video元素const videos document.querySelectorAll(video);if (videos.length…
閱讀更多...
Linux內核在啟動過程中掛載根文件系統rootfs的過程

Linux內核在啟動過程中掛載根文件系統rootfs的過程

一、掛載根文件系統rootfs的過程&#xff1a; 1. ?初始虛擬根文件系統的掛載? 內核啟動時首先會創建并掛載一個?臨時虛擬根文件系統&#xff08;如initramfs或rootfs&#xff09;??15。該階段主要作用&#xff1a; 提供基礎的設備節點和目錄結構&#xff0c;確保內核能訪…
閱讀更多...
【LeetCode】力扣題——輪轉數組、消失的數字、數組串聯

【LeetCode】力扣題——輪轉數組、消失的數字、數組串聯

&#x1f525;個人主頁&#xff1a;艾莉絲努力練劍 ?專欄傳送門&#xff1a;《C語言》、《數據結構與算法》、C語言刷題12天IO強訓 &#x1f349;學習方向&#xff1a;C/C方向 ??人生格言&#xff1a;為天地立心&#xff0c;為生民立命&#xff0c;為往圣繼絕學&#xff0c;…
閱讀更多...
Java Stream詳解

Java Stream詳解

Java Stream詳解 Stream 是 Java 8 引入的流式數據處理工具&#xff0c;可以像流水線一樣對集合數據進行高效操作&#xff08;過濾、轉換、統計等&#xff09;。核心特點&#xff1a; 鏈式操作&#xff1a;支持多個操作串聯不修改原始數據&#xff1a;生成新結果支持并行處理…
閱讀更多...
Java回歸循環理解

Java回歸循環理解

一、Java循環的四種 1. 傳統for循環 - 精確控制的首選 // 遍歷數組 int[] numbers {1, 2, 3, 4, 5}; for (int i 0; i < numbers.length; i) {System.out.println(numbers[i]); }// 嵌套示例&#xff1a;矩陣遍歷 int[][] matrix {{1, 2}, {3, 4}}; for (int row 0; r…
閱讀更多...
飛騰D2000金融工控主板，點亮經濟高質量發展

飛騰D2000金融工控主板，點亮經濟高質量發展

近年來&#xff0c;國家不斷推出金融行業的政策和法規&#xff0c;推動金融業高質量發展。在國家大力推進金融行業改革和創新的大環境下&#xff0c;金融工控主板市場也迎來了新的發展機遇。隨著國產CPU技術的不斷突破&#xff0c;以及我國對金融安全重視程度的提高&#xff0c…
閱讀更多...
SimpleITK——創建nrrd體素模型

SimpleITK——創建nrrd體素模型

在介紹如何生成nrrd前&#xff0c;了解一下為什么醫學影像上一般使用nrrd的體素模型&#xff1f; 為什么醫學影像上一般使用nrrd的體素模型&#xff1f; 在醫學影像領域&#xff0c;?NRRD&#xff08;Nearly Raw Raster Data&#xff09;格式?被廣泛用于存儲體素模型&#x…
閱讀更多...
Docker容器部署KES

Docker容器部署KES

一、安裝部署 1&#xff0c;導入鏡像 #導入鏡像&#xff08;root用戶&#xff09; [rootnode docker ]# mv kdb_x86_64_V008R006C009B0014.tar kingbase.tar [rootnode docker]# docker load -i kingbase.tar#查看鏡像&#xff08;root用戶&#xff09; [rootnode docker]# d…
閱讀更多...
C++基礎練習 sort函數，用于排序函數

C++基礎練習 sort函數，用于排序函數

題目&#xff1a; https://acm.hdu.edu.cn/showproblem.php?pid2039 解答&#xff1a; #include <iostream> #include <cmath> #include <algorithm> using namespace std;double a[3]; int main(){int n;cin>>n;while(n--){cin>>a[0]>>…
閱讀更多...
最新文章

Copyright @ 2022~2023