❶ c語言的 char** 和 golang []string類型怎麼相互轉換
當a是一個指針的時候，*a就是這個指針指向的內存的值 在定義的時候加了*的都是指針變數，都棗悉沖是一個地址。 在賦值的時候加了*的都凳殲是表示陸汪這個指針指向內存的值，在等號前面就是給這個值賦值，後面就是取這個值。
❷ go與c++的兼容性
不高。c語言和go是雙種不同乎蘆的計算機語言拿神語法各不相同，所以兼容不高。C++是C語言的繼承，它既可以進行C語言的過程化歲敏帶程序設計，又可以進行以抽象數據類型為特點的基於對象的程序設計。
❸ 如何在golang 中調用c的靜態庫或者動態庫
1. 無論調用動態庫還是靜態庫都只需要include庫的頭文件就可以了
2. 要在調用該靜態庫的地方添加庫引用，並設置路徑。
結論：其實靜態庫調用動態庫或者靜態庫，只是在用到庫方法的地方把該方法添加到LIB當中，真正使用的地方才會把這些庫LINK起來生成可執行文件。
❹ Go語言是不是C語言的下一跳
1：go與c語言相比，go有垃圾回收，不會造成內存泄露問題，go的語法簡潔優美，同樣的c++100行代碼go大概50行可以做到，go的目標是能做C++能做的事，雖然目前可能不太實際
2：go的並行機制並不是一般的線程，通過channel和goroutine來實現，比線程還要輕量級很多，所以go適合高並發的伺服器端
3：go是系統級別的語言，相當於c語言，java c#都是算比較高級的語言，這個不太好比，效率的話目前確實是要高一些，而且不需要外部依賴，所以go還是很強大的
❺ go的uint64轉換成java的哪種類型
Golang 和java/c不同，Go在不同類型的變數之間賦值時需要顯式轉換。也就是說Golang中數據類型不能自動轉換。
基本語法
表達式T（v））將值v 轉換為類型T
T∶就是數據類型，比如int32，int64，float32等等
v∶ 就是需要轉換的變數
var i int = 100
var b float64 = float64(i)
var c int64 = int64(b)
fmt.Printf("b=%f,c=%d",b,c)
b=100.000000,c=100
登錄後復制
細節說明
1）Go中，數據類型的轉換可以是從表示範圍小->表示範圍大，也可以范圍大一>范圍小
2） 被轉換的是變數存儲的數據（即值），變數本身的數據類型並沒有變化!
3） 在轉換中，比如將 int64 轉成int8，編譯時不會報錯，只是轉換的結果是按溢出處理，和
我們希望的結果不一樣。（在轉換的時候需要注意范圍）
var a int64 = 10000000
var b int8 = int8(a)
fmt.Printf("%d",b)
-128
登錄後復制
可以看到在轉換的時候，一定要保證轉換升畝大數據要是對方可以接受的范圍。
n1類型是int32，那麼➕20整個就是int32類型，可是n2是int64，這樣就會編譯錯誤。
題二n4是12 + 127溢出超過了范圍，運行此笑亂的時候按照溢出處理。n3是直接編譯不通過，128已經超過了int8類型的范圍
基本數據類型和string的轉換
字元串格式化
Go語言用於控制文本輸出常用的標准庫是fmt
fmt中主要用於輸出的函數有:
Print: 輸出到控制台,不接受任何格式化操作
Println: 輸出到控制台並換行
Printf : 只可以列印出格式化的字元串。只可以直接輸出字元串類型的變數（不可以輸出別的類型）
Sprintf：格式化並返回一個字元串而不帶任何輸出
Fprintf：來格式化並輸出到 io.Writers 而不是 os.Stdout
整數類型
格 式 描 述
%b 整型以二進制方式顯示
%o 整型以八進制方式顯示
%d 整型以十進制森檔方式顯示
%x 整型以十六進制方式顯示
%X 整型以十六進制、字母大寫方式顯示
%c 相應Unicode碼點所表示的字元
%U Unicode 字元, Unicode格式：123，等同於 "U+007B"
浮點數
格 式 描 述
%e 科學計數法，例如 -1234.456e+78
%E 科學計數法，例如 -1234.456E+78
%f 有小數點而無指數，例如 123.456
%g 根據情況選擇 %e 或 %f 以產生更緊湊的（無末尾的0）輸出
%G 根據情況選擇 %E 或 %f 以產生更緊湊的（無末尾的0）輸出
布爾
格 式 描 述
%t true 或 false
字元串
格 式 描 述
%s 字元串或切片的無解譯位元組
%q 雙引號圍繞的字元串，由Go語法安全地轉義
%x 十六進制，小寫字母，每位元組兩個字元
%X 十六進制，大寫字母，每位元組兩個字元
指針
格 式 描 述
%p 十六進製表示，前綴 0x
var num1 int64 = 99
var num2 float64 = 23.99
var b bool = true
var mychar byte = 'h'
str1 := fmt.Sprintf("%d",num1)
str2 := fmt.Sprintf("%f",num2)
bool1 := fmt.Sprintf("%t",b)
mychar1 := fmt.Sprintf("%c",mychar)
fmt.Printf("%T,%T,%T,str1=%v,str2=%v,bool1=%v,mychar1=%v",str1,bool1,str2,str1,str2,bool1,mychar1)
string,string,string,string,str1=99,str2=23.990000,bool1=true,mychar1=h
登錄後復制
使用strconv包 基本類型 -> string類型
num1 := 99
str1 := strconv.FormatInt(int64(num1),10)
fmt.Printf("%T,%v",str1,str1)
num2 := 99.99
str2 := strconv.FormatFloat(num2,'f',10,64)
fmt.Printf("%T,%v\n",str2,str2)
登錄後復制
strconv包提供了字元串與簡單數據類型之間的類型轉換功能，可以將簡單類型轉換為字元串，也可以將字元串轉換為其它簡單類型
string和int轉換
int轉string的方法是: Itoa()
str := strconv.Itoa(100)
fmt.Printf("type %v, value: %s\n", reflect.TypeOf(str), str)
登錄後復制
2.string轉int的方法是:
i, err := strconv.Atoi("100")
fmt.Printf("type %v, value: %d, err: %v\n", reflect.TypeOf(i), i, err)
登錄後復制
並不是所有string都能轉化為int, 所以可能會報錯:
i, err := strconv.Atoi("100x")
fmt.Printf("type %v, value: %d, err: %v\n", reflect.TypeOf(i), i, err)
登錄後復制
使用strconv包 string轉其他類型
strconv包提供的Parse類函數用於將字元串轉化為給定類型的值：ParseBool()、ParseFloat()、ParseInt()、ParseUint() 由於字元串轉換為其它類型可能會失敗，所以這些函數都有兩個返回值，第一個返回值保存轉換後的值，第二個返回值判斷是否轉換成功。
1.轉bool
b, err := strconv.ParseBool("true")
fmt.Println(b, err)
登錄後復制
2.轉float
f1, err := strconv.ParseFloat("3.1", 32)
fmt.Println(f1, err)
f2, err := strconv.ParseFloat("3.1", 64)
fmt.Println(f2, err)
登錄後復制
由於浮點數的小數部分 並不是所有小數都能在計算機中精確的表示, 這就造成了浮點數精度問題, 比如下面
var n float64 = 0
for i := 0; i < 1000; i++ {
n += .01
}
fmt.Println(n)
關於浮點數精度問題: c計算機不都是0101嗎，你有想過計算機是怎麼表示的小數嗎, 簡單理解就是:
將其整數部分與小樹部分分開, 比如5.25
對於整數部分 5 ，我們使用"不斷除以2取余數"的方法，得到 101
對於小數部分 .25 ，我們使用"不斷乘以2取整數"的方法，得到 .01
聽說有一個包可以解決這個問題: github.com/shopspring/decimal
3.轉int
func ParseInt(s string, base int, bitSize int) (i int64, err error)
base: 進制，有效值為0、2-36。當base=0的時候，表示根據string的前綴來判斷以什麼進制去解析：0x開頭的以16進制的方式去解析，0開頭的以8進制方式去解析，其它的以10進制方式解析
bitSize: 多少位，有效值為0、8、16、32、64。當bitSize=0的時候，表示轉換為int或uint類型。例如bitSize=8表示轉換後的值的類型為int8或uint8
fmt.Println(bInt8(-1)) // 0000 0001(原碼) -> 1111 1110(反碼) -> 1111 1111
// Parse 二進制字元串
i, err := strconv.ParseInt("11111111", 2, 16)
fmt.Println(i, err)
// Parse 十進制字元串
i, err = strconv.ParseInt("255", 10, 16)
fmt.Println(i, err)
// Parse 十六進制字元串
i, err = strconv.ParseInt("4E2D", 16, 16)
fmt.Println(i, err)
4.轉uint
func ParseUint(s string, base int, bitSize int) (uint64, error)
用法和轉int一樣, 只是轉換後的數據類型是uint64
u, err := strconv.ParseUint("11111111", 2, 16)
fmt.Println(u, err)
u, err = strconv.ParseUint("255", 10, 16)
fmt.Println(u, err)
u, err = strconv.ParseUint("4E2D", 16, 16)
fmt.Println(u, err)
其他類型轉string
將給定類型格式化為string類型：FormatBool()、FormatFloat()、FormatInt()、FormatUint()。
fmt.Println(strconv.FormatBool(true))
// 問題又來了
fmt.Println(strconv.FormatInt(255, 2))
fmt.Println(strconv.FormatInt(255, 10))
fmt.Println(strconv.FormatInt(255, 16))
fmt.Println(strconv.FormatUint(255, 2))
fmt.Println(strconv.FormatUint(255, 10))
fmt.Println(strconv.FormatUint(255, 16))
fmt.Println(strconv.FormatFloat(3.1415, 'E', -1, 64))
func FormatFloat(f float64, fmt byte, prec, bitSize int) string
bitSize表示f的來源類型（32：float32、64：float64），會據此進行舍入。
fmt表示格式：'f'（-ddd.dddd）、'b'（-ddddp±ddd，指數為二進制）、'e'（-d.dddde±dd，十進制指數）、'E'（-d.ddddE±dd，十進制指數）、'g'（指數很大時用'e'格式，否則'f'格式）、'G'（指數很大時用'E'格式，否則'f'格式）。
prec控制精度（排除指數部分）：對'f'、'e'、'E'，它表示小數點後的數字個數；對'g'、'G'，它控制總的數字個數。如果prec 為-1，則代表使用最少數量的、但又必需的數字來表示f。
❻ go類型轉換
type_name(expression)
float跟int可以互轉，但是會丟失所有精度。
func AppendBool(dst []byte, b bool) []byte
AppendBool 根據 b 的值將「true」或「false」附加到 dst 並返回擴展緩沖區。
func AppendFloat(dst []byte, f float64, fmt byte, prec, bitSize int) []byte
AppendFloat 將由 FormatFloat 生成的浮點數 f 的字元串形式附加到 dst 並返回擴展緩沖區。
func AppendInt(dst []byte, i int64, base int) []byte
AppendInt 將由 FormatInt 生成的整數i的字元串形式附加到 dst 並返回擴展緩沖區。
func AppendQuote(dst []byte, s string) []byte
AppendQuote 將由 Quote 生成的代表 s 的雙引號 Go 字元串文字附加到 dst 並返回擴展緩沖區。
func AppendQuoteRune(dst []byte, r rune) []byte
AppendQuoteRune 將由 QuoteRune 生成的表示符文的單引號 Go 字元文字附加到 dst 並返回擴展緩沖區。
func AppendQuoteRuneToASCII(dst []byte, r rune) []byte
AppendQuoteRuneToASCII 將由 QuoteRuneToASCII 生成的代表該符文的單引號 Go 字元文字附加到 dst 並返回擴展緩沖區。
func AppendQuoteRuneToGraphic(dst []byte, r rune) []byte
AppendQuoteRuneToGraphic 將由 QuoteRuneToGraphic 生成的表空毀示符文的單引號 Go 字元文字附加到 dst 並返回擴展緩沖區。
func AppendQuoteToASCII(dst []byte, s string) []byte
AppendQuoteToASCII 將由 QuoteToASCII 生成的代表 s 的雙引號 Go 字元串文字附加到 dst 並返回擴展緩沖區斗迅備。
func AppendQuoteToGraphic(dst []byte, s string) []byte
AppendQuoteToGraphic 將由 QuoteToGraphic 生昌豎成的代表 s 的雙引號 Go 字元串文字附加到 dst 並返回擴展緩沖區。
func AppendUint(dst []byte, i uint64, base int) []byte
AppendUint 將由 FormatUint 生成的無符號整數 i 的字元串形式附加到 dst 並返回擴展緩沖區。
func Atoi(s string) (int, error)
Atoi 返回 ParseInt(s, 10, 0) 轉換為 int 類型的結果。
func CanBackquote(s string) bool
CanBackquote 報告字元串 s 是否可以不改變為單行反引號字元串，而不包含 tab 以外的控制字元。
func FormatBool(b bool) string
FormatBool 根據 b 的值返回「true」或「false」
func FormatFloat(f float64, fmt byte, prec, bitSize int) string
FormatFloat 根據格式 fmt 和 precision prec 將浮點數f轉換為字元串。它將結果進行四捨五入，假設原始數據是從 bitSize 位的浮點值獲得的（float32為32，float64為64）。
格式 fmt 是 'b'（-ddddp±ddd，二進制指數），'e'（-d.dddde±dd，十進制指數），'E'（-d.ddddE±dd，十進制指數），'f'（-ddd.dddd，無指數），'g'（'e'表示大指數，'f'表示否則）或 'G'（'E'表示大指數，否則'f'）。
precision prec 控制由 'e'，'E'，'f'，'g' 和 'G' 格式列印的位數（不包括指數）。對於 'e'，'E' 和 'f'，它是小數點後的位數。對於 'g' 和 'G' 這是總位數。特殊精度-1使用必需的最小位數，以便 ParseFloat 完全返回 f 。
func FormatInt(i int64, base int) string
FormatInt 返回給定基數中的i的字元串表示，對於2 <= base <= 36.結果對於數字值> = 10使用小寫字母 'a' 到 'z' 。
func FormatUint(i uint64, base int) string
FormatUint 返回給定基數中的 i 的字元串表示，對於2 <= base <= 36.結果對於數字值> = 10使用小寫字母 'a' 到 'z' 。
func IsGraphic(r rune) bool
IsGraphic 報告符文是否被 Unicode 定義為 Graphic。這些字元包括類別 L，M，N，P，S 和 Z 中的字母，標記，數字，標點，符號和空格。
func IsPrint(r rune) bool
IsPrint 報告該符文是否被 Go 定義為可列印，其定義與 unicode.IsPrint 相同：字母，數字，標點，符號和 ASCII 空格。
func Itoa(i int) string
Itoa 是 FormatInt(int64(i), 10) 的縮寫。
func ParseBool(str string) (bool, error)
ParseBool 返回字元串表示的布爾值。它接受1，t，T，TRUE，true，True，0，f，F，FALSE，false，False。任何其他值都會返回錯誤。
func ParseFloat(s string, bitSize int) (float64, error)
ParseFloat 將字元串 s 轉換為浮點數，精度由 bitSize：32指定，float32為64; float64為64。當 bitSize = 32時，結果仍然具有 float64 類型，但可以在不更改其值的情況下將其轉換為 float32。
如果s格式良好且接近有效的浮點數，則 ParseFloat 返回使用 IEEE754 無偏舍入舍入的最近浮點數。
ParseFloat 返回的錯誤具有具體類型 * NumError 並包含 err.Num = s。
如果 s 在語法上不是格式良好的，ParseFloat 返回 err.Err = ErrSyntax。
如果 s 在語法上格式良好，但距離給定大小的最大浮點數大於1/2 ULP，則 ParseFloat 返回 f =±Inf，err.Err = ErrRange。
func ParseInt(s string, base int, bitSize int) (i int64, err error)
ParseInt 解釋給定基礎（2到36）中的字元串 s 並返回相應的值 i。如果 base == 0，則基數由字元串的前綴隱含：base 16代表「0x」，base 8代表「0」，否則以10為底數。
bitSize 參數指定結果必須適合的整數類型。位大小 0,8,16,32 和 64 對應於 int，int8，int16，int32 和 int64。
ParseInt 返回的錯誤具有具體類型 * NumError 並包含err.Num = s。如果s為空或包含無效數字，則 err.Err = ErrSyntax，返回值為0; 如果與s對應的值不能用給定大小的有符號整數表示，則 err.Err = ErrRange，返回的值是相應 bitSize 和符號的最大幅度整數。
func ParseUint(s string, base int, bitSize int) (uint64, error)
ParseUint 就像 ParseInt，但是對於無符號數字。
func Quote(s string) string
Quote 返回一個雙引號的 Go 字元串字面表示s。返回的字元串使用 Go 轉義序列 (\t, \n, \xFF, \u0100) 作為 IsPrint 定義的控制字元和非可列印字元。
func QuoteRune(r rune) string
QuoteRune 返回一個表示符文的單引號 Go 字元。返回的字元串使用 Go 轉義序列(\t, \n, \xFF, \u0100) 作為 IsPrint 定義的控制字元和非可列印字元。
func QuoteRuneToASCII(r rune) string
QuoteRuneToASCII 返回表示符文的單引號 Go 字元。對於非 ASCII 字元和 IsPrint 定義的非可列印字元，返回的字元串使用 Go 轉義序列 (\t, \n, \xFF, \u0100)。
func QuoteRuneToGraphic(r rune) string
QuoteRuneToGraphic 返回代表符文的單引號 Go 字元。對於非 ASCII 字元和 IsGraphic 定義的非可列印字元，返回的字元串使用Go轉義序列 (\t, \n, \xFF, \u0100)。
func QuoteToASCII(s string) string
QuoteToASCII 返回一個代表 s 的雙引號 Go 字元串。對於非 ASCII 字元和 IsPrint 定義的非可列印字元，返回的字元串使用 Go 轉義序列 (\t, \n, \xFF, \u0100) 。
func QuoteToGraphic(s string) string
QuoteToGraphic 返回一個代表 s 的雙引號 Go 字元串。對於非 ASCII 字元和 IsGraphic 定義的非可列印字元，返回的字元串使用 Go 轉義序列 (\t, \n, \xFF, \u0100)。
func Unquote(s string) (string, error)
Unquote 將 s 解釋為單引號，雙引號或反引號的 Go 字元串文字，返回引用的字元串值。（如果 s 是單引號，它將是一個 Go 字元字面量； Unquote 會返回相應的一個字元字元串。）
❼ Go語言可能會代替C語言嗎
不可能。Go到目前為止，其本身就是用C寫的。只是在語言層面實現了一些如果用C會很難寫的feature，比如goroutine。在1.5版本中，Go會bootstraping，用Go來編譯自己。
C語言，幾乎每種操作系統的系統調用都是C，C最大的作用就是用來實現新的語言。
❽ c語言的 char** 和 golang []string類型怎麼相互轉換
var gostrs []string
var cstrs []*C.char
header := (*reflect.SliceHeader)(unsafe.Pointer(&cstrs))
header.Data = cstrspointer
header.Len = cstrslength
for _, cstr := range cstrs {
gostrs = append(gostrs, C.GoString(cstr))
}
❾ go語言能取代C語言嗎
不能吧，現在用C語言搞開發都是用在更加底層的開發中，更加底層的開發需要高運行效率，go語言的運行效率是比不上C語言的，所以go語言在這些方面還無法取代C語言。應該說是各有所長吧，go和C都有它們自己的適用環境，誰也不能取代誰。