����λ�ã���ҳ > �����̳� > �̳� > golang������ת��

golang������ת��

��Դ������������|��ʱ�䣺2024-09-30 10:04:56 |���Ķ���185��|�� ��ǩ�� a Golang GO �� |����������

����������˵˵һ�����ÿ�춼��������������˼���IJ�����������ת���� �������� һ����ֵĴ��� go������ת�� ��ֵ����֮�以��ת�� unsafe��ص�ת�� �ַ�����byte��rune��Ƭ��ת�� sliceת�������� �ײ�������ͬʱ��ת�� ����������Ǹ�ɶ��� �ܽ� һ����ֵĴ��� ����ʼ�����ʱ�Ҷ�

����������˵˵һ�����ÿ�춼��������������˼���IJ�����������ת����

��������

  • һ����ֵĴ���
  • go������ת��
    • ��ֵ����֮�以��ת��
    • unsafe��ص�ת��
    • �ַ�����byte��rune��Ƭ��ת��
    • sliceת��������
    • �ײ�������ͬʱ��ת��
  • ����������Ǹ�ɶ���
  • �ܽ�

һ����ֵĴ���

����ʼ�����ʱ�ҶԱ�׼��sync��һЩ�Ķ���ʱ��

�Ķ����õ���׼����1.19�����ӵ� atomic.Pointer �����ڽ��������ڽ��б��֮ǰ����ͨ����һ�����Ĵ��룬Ȼ��һ�д����������ҵ�ע�⣺

// A Pointer is an atomic pointer of type *T. The zero value is a nil *T.
type Pointer[T any] struct {
    // Mention *T in a field to disallow conversion between Pointer types.
    // See go.dev/issue/56603 for more details.
    // Use *T, not T, to avoid spurious recursive type definition errors.
    _ [0]*T

    _ noCopy
    v unsafe.Pointer
}

������noCopy��������� golangʰ�ţ�ʵ��һ�����ɸ������� ��ϸ�������

������ע��ĵط��� _ [0]*T �����Ǹ������ֶΣ��ҳ���Ϊ������鲻��ռ���ڴ档�Ⲣ��Ӱ����Ҫ�޸ĵĴ��룬������������ʲô�������ҵĺ��档

��������ֶ��Լ���ע�͸����˴𰸣�����ֶ���Ϊ�˷�ֹ���������ת����ʲô��������ת����Ҫ������ֶ��������ء����������ҵ㿪�˸�����issue���ӣ�Ȼ�󿴵�����������ӣ�

package main

import (
	"math"
	"sync/atomic"
)

type small struct {
	small [64]byte
}

type big struct {
	big [math.MaxUint16 * 10]byte
}

func main() {
	a := atomic.Pointer[small]{}
	a.Store(&small{})

	b := atomic.Pointer[big](a) // type conversion
	big := b.Load()

	for i := range big.big {
		big.big[i] = 1
	}
}

���ӳ���ᵼ���ڴ������Linux�����������кܴ���ʵ��¶δ���Ϊʲô�أ���Ϊbig������ֵ��󳬹���small�ķ�Χ��������ʵ������Pointerֻ����һ��small��������������ѭ���������Ƿ���������Խ�磬����go��û�м�⵽���Խ�硣

��Ȼ��goҲû������ȥ�������Խ�磬��Ϊ����unsafe��atomic.Pointer�Ƕ�unsafe.Pointer�İ�װ��֮�����Ͱ�ȫ���ڴ氲ȫ��ֻ�ܿ��û��Լ��������ˡ�

��������ϵ��������ڣ� atomic.Pointer[small] �� atomic.Pointer[big] ֮��û���κι���������Ӧ������ȫ��ͬ�����Ͳ�Ӧ�÷���ת��������Դ����ɻ󣬿������������͹�������ص����ϣ�ͨ�����ַ��͵����͹���������������֮���Dz�Ӧ�����κι����Եģ���������go��һ��ǿ�������ԣ����Ƶ�������c++�޷�ͨ���������python���������ʱ������

����ʵ����û���ӿ�ͷ���Ǹ��ֶ�ǰ����ת���ǺϷ��Ķ����ڷ��������к����׳��֡�

����������ܻ����е������������û��ϵ��������һ������ƿ���ɢ�ġ�

go������ת��

golang�ﲻ������ʽ����ת���������Ҫ��һ�����͵�ֵת������һ�����ͣ�ֻ���������ı���ʽ Type(value) ������ʽ���value����һ��Ȼ��ת����Type���͡�

���������ͳ�������Ҫ��΢���һЩ�����ǿ��������������Զ�ת������Ӧ�����ͣ�����ҵ���һƪ���� golang�е������ͳ��� ��

�׿�������cgo��golang������ת�����Է�Ϊ�ü��࣬����������һЩ�Ƚϳ��������͡�

��ֵ����֮�以��ת��

�����൱������ת����

�����ʵûʲô��˵�ģ����Ӧ��ÿ�춼��д���ƵĴ��룺

c := int(a+b)
d := float64(c)

��ֵ����֮������໥ת���������͸���֮��Ҳ�ᰴ����Ӧ�Ĺ������ת������ֵ�ڱ�Ҫ��ʱ��ᷢ������/�ضϡ�

���ת�������˵Ҳ�Ƚϰ�ȫ��ΨһҪע����������

unsafe��ص�ת��

unsafe.Pointer �����е�ָ������֮�䶼���Ի���ת�������� unsafe.Pointer ת����������֤���Ͱ�ȫ��

unsafe.Pointer �� uintptr ֮��Ҳ���Ի���ת����������Ҫ��һЩϵͳ��api��Ҫʹ�á�

��Щת����go��runtime�Լ�һЩ�ض�����ϵͳ��̵Ĵ����ᆳ�����֡���Щת����Σ�գ�����DZ�Ҫ��ʹ�á�

�ַ�����byte��rune��Ƭ��ת��

���ת���ij���Ƶ��Ӧ�ý�������ֵת����

fmt.Println([]byte("hello"))
fmt.Println(string([]byte{104, 101, 108, 108, 111}))

���ת��go���˲����Ż���������ʱ����Ϊ����ͨ������ת���е���룬����ܶ�ʱ�����ݸ��ƻᱻ�Ż�����

rune�Ͳ������ˣ�������û��̫��IJ��

sliceת��������

go1.20֮������sliceת�������飬�ڸ��Ʒ�Χ�ڵ�slice��Ԫ�ػᱻ���ƣ�

s := []int{1,2,3,4,5}
a := [3]int(s)
a[2] = 100
fmt.Println(s)  // [1 2 3 4 5]
fmt.Println(a)  // [1 2 100]

�������ij��ȳ�����slice�ij��ȣ�ע�ⲻ��cap�������panic��ת���������ָ��Ҳ�ǿ��Եģ�������ȫ��ͬ��

�ײ�������ͬʱ��ת��

�������۵ļ�����Ȼ�ܳ���������ʵ������������������Ϊ��Щת��ֻ�����ض�������֮���ұ�������ʶ����Щת�������ɲ�ͬ�Ĵ��롣

��go��ʵ������һ��������IJ���Ҫ��ô�����⴦����ת�����ײ�������ͬ������֮����Ի���ת����

�ٸ����ӣ�

type A struct {
    a int
    b *string
    c bool
}

type B struct {
    a int
    b *string
    c bool
}

type B1 struct {
    a1 int
    b *string
    c bool
}

type A1 B

type C int
type D int

A��B����ȫ��ͬ�����ͣ������ǵĵײ����Ͷ��� struct{a int;b *string;c bool;} ��C��DҲ����ȫ��ͬ�����ͣ������ǵĵײ����Ͷ���int��A1������B��A1��B������ͬ�ĵײ����ͣ�����A1��AҲ����ͬ�ĵײ����͡�B1��Ϊ�и��ֶε����ֺͱ��˶���һ��������û�˺����ĵײ�������ͬ��

�ֱ�һ��˵���ײ����ͣ�underlying type���Ǹ����������ͣ�int��string��slice��map��...���Լ� struct{...} ���ֶ������Ƿ�export�ᱻ���ǽ�ȥ�����������ͺ� struct{...} �ĵײ����;����Լ���

ֻҪ�ײ�������ͬ������֮����ܻ���ת����

func main() {
    text := "hello"
    a := A{1, &text, false}
    a1 := A1(a)
    fmt.Printf("%#v\n", a1) // main.A1{a:1, b:(*string)(0xc000014070), c:false}
}

A1��B�������е��ϵ������A����İ˸��Ӵ��ţ����ǵij�����Ա��벢�����еĺܺá�����ǵײ�������ͬ������֮����Ի���ת���Ĺ����µġ�

����struct tag��ת�����ǻᱻ���Եģ����ֻҪ�ֶ����ֺ�������ͬ������tag�Dz�����ͬ�Ķ����Խ���ת����

��������������һЩû�й�ϵ�����ͽ���˫���ת����զһ��������������������������������Ҳ������ȫû�ã�

type IP []byte

��������һ�����ͣ�IP���Ա�ʾΪһ��byte�����У�����RFC�ĵ�����ȷ˵���ģ�����������ô��������������ʵ�ϴ��Ҳ������ô�ɵģ�����Ϊ��byte�����У�����������Ȼ���һЩ����byte��Ƭ�ķ���/��������IP����ʵ�ִ��븴�úͼ򻯿�����

��������Щ���붼�ٶ��Լ��IJ���/����ֵ�� []byte ������IP������֪��IP��ʵ���� []byte ����go��������ʽ����ת��������ֱ����IP��ֵȥ����Щ�����Dz��еġ�����һ�����û�еײ�������ͬ������֮������໥ת�������������Ҫ��ô������Щ�����أ��϶�ֻ����һЩunsafe������а���ˡ����������������� []byte(ip) �� IP(bytes) ��ת����

Ϊɶ������סֻ������ IP �� []byte ֮��������ת���أ���Ϊ�����ᵼ�����ͼ���ø��ӻ�Ҫ���۱����ٶȣ�go��صľ��DZ�����������Լ������ٶȿ죬��Ȼ��Ը�������Щ����������ֱ�ӷſ���׼�õײ�������ͬ���͵Ļ���ת�����ļ򵥿�ݡ�

����������Ǻ�Σ�յģ�������������ǰ��˵�� atomic.Pointer �����⡣

���ǿ��³���� atomic.Pointer �Ĵ��룺

type Pointer[T any] struct {
    _ noCopy
    v unsafe.Pointer
}

���Ͳ���ֻ���� Store �� Load ��ʱ���������� unsafe.Pointer ������ָ��֮�������ת���ġ���ᵼ��һ������ȱ�ݣ����� atomic.Pointer ��������ͬ�ĵײ����� struct{_ noCopy;v unsafe.Pointer;} ��

���Բ����� atomic.Pointer[A] �� atomic.Pointer[B] ���� atomic.Pointer[small] �� atomic.Pointer[big] �����Ƕ�����ͬ�ĵײ����ͣ�����֮������������ת����

���¾ͳ��������ף���˵�û����Լ�Ϊunsafe���𣬵����������ŵ����������Ͳ��ñ���ͨ���Ĵ�������ȴ�������û����޷���������³����ڴ��������ͨ�����߿ɲ��Ứʱ����ı�׼������ôʵ�ֵ����Բ�֪�� atomic.Pointer ��unsafe��ʲô��ϵ��

go�Ŀ�������������� _ [0]*T ����������ʵ������ÿһ�� atomic.Pointer ��ֻҪT��ͬ�����ǵĵײ����;ͻ᲻ͬ������Ĵ��������ת���Ͳ����ܷ���������ѡ�� *T ���ܷ�ֹ�����õ��� atomic.Pointer[atomic.Pointer[...]] �����Ĵ�����뱨����

������Ӧ��Ҳ������Ϊʲô��˵���������������������������ˣ�ֻҪ��ķ��������Ǹ��ṹ����������������ͣ������ֶλ��߸���������û��ʹ�õ��������Ͳ�������ô�������������ʵ�����������������;��п�������ͬ�ĵײ����ͣ��Ӷ�����issue��������������ȫ���������ת�����֡�

����������Ǹ�ɶ���

���ڽṹ���������ԣ���go�����ײ�������ͬ�Ϳ��Ի���ת�����ڻ��٣���ͬ���Ի��ʵ��ſ�/��������ת����˵���˾���ֻ�Ͻṹ���������ģ��ṹ��ͬ�Ķ�������ô���ڶ�����ͬһ�ࡣ���issue��������������Щ����������not even wrong���������Ҫ�ı�������ر����Ƶ����⡣

����ʹ����������ϵͳ�����ԣ�������ͬ����ͬһ�಻ͬ�����½ṹ��һ��Ҳ�Dz�ͬ���͡�˳��һ�ᣬc++��golang��rust��������һ���͡�golang�ĵײ�������Ȼ������ת��������Լ���ϱ��ֵ���ṹ�����ͣ���������Ϊ����Ȼƫ�����������ͣ��ٷ���û����ȷ�����Լ���������������ϵͳ������Ȩ�����ҵ�һ��֮��Ҳ�С�

��ȫ�Ľṹ���������Բ���ô��������Ǿ��Գ�����������������c++��ʹ��Ѽ�����͵�pythonΪ����

��python�����ǿ����Զ������͵Ĺ��캯������˿����ڹ��캯����ʵ������ת�����߼����������û���Զ��幹�캯�����������Ŀ��Է��������͵��෽��������������֮��Ĭ�����޷�����ת����������python���Dz�����ֺ�goһ��������ġ�

c++��python���ƣ��û����Զ���Ļ�Ĭ�ϲ�������κ�ת��;������python��һ���ĵط�����c++���˹��캯��֮�⻹��ת�����������֧�� �ڹ��������µ���ʽת�� ���û���Ҫ�Լ�����ת�����캯��/ת��������������﷨����������²���ʵ��������ͬ���ͼ��ת�������ת���ǵ�����˫���pythonһ�����û��Լ����ơ�����c++��Ҳ������go�����⡣

����rust��Java��...�ҾͲ�һһ�о��ˡ�

�ܶ���֮��Ҳ��go��������һ�����桪������һЩ�����������ѳ��ֵ�����Ȼ���ü����ֶ�ȥ�޸���

�ܽ�

���Ǹ�ϰ��go�������ת������˳�����һ����صĿӡ�

��������������飺

  • ���÷����ֲ���ȿӣ������ڽṹ���ֶλ��߸���������ʹ�÷������Ͳ�����ʹ�� _ [0]*T �������ֶβ���ʹ�����������⣬���������͵ij�ʼ�����鷳������ atomic.Pointer �����ò²»µï¿½ï¿½Ôµï¿½Ê±ï¿½ï¿½ï¿½Ò²ï¿½ï¿½ï¿½ï¿½Æ¼ï¿½Ê¹ï¿½Ã¡ï¿½
  • ���÷��͵����±�����ͺ��Լ�����������ͬ�ĵײ����ͣ������£����Զ�����������������ת�����﷨�����ˣ�����������Ҫ������Զ�������֮��ת��������һЩ toTypeA ֮��ķ���������ת�����̾�������ƵIJ�����goĬ�ϵ��ˡ�
  • ���������ͺͻ�����Щ���͵��Զ�������֮��ת�������ûɶ�õ��ĵģ���Ϊ��������������Ҿ�����Ĺ�ϵ��ʵ�ھ��ò�������Բ��� type T []int �������Ͷ��廻�� type T struct { data []int } �����۳��˴���䆪���⻹�кܶ������Ƭ�����ĺ�����rangeѭ��û��ֱ�����ˡ�

��go�����ڼ򵥵��﷨�����ﰵ��ɱ�������Ի���ͦ����˼�ģ����ֻ�����ٳɵĻ�ָ����ʲôʱ��Ͳȵ������ˡ�

С���Ƽ��Ķ�

�������������Ľ�Ϊ������Ϣ����������������ͬ���޹۵��֤ʵ��������

a 1.0
a 1.0
���ͣ���������������Ӫ״̬����ʽ��Ӫ�������ԣ����� ����

��Ϸ����

��Ϸ���

��Ϸ��Ƶ

��Ϸ����

��Ϸ�

��alittletotheleft������������һ��ܻ�ӭ����������������Ϸ����ҵ������Ƕ��ճ������еĸ���������
Go v1.62
Go v1.62
���ͣ�����ð��������Ӫ״̬����ʽ��Ӫ�������ԣ����� ����

��Ϸ����

��Ϸ���

��Ϸ��Ƶ

��Ϸ����

��Ϸ�

GoEscape��һ���Թ��������д�����Ϸ���������Ϸ�У���ҿ�����ս�����ؿ���ͨ����ת��Ļ�ķ�ʽ��������

�����Ƶ����

����

ͬ������

����

ɨ��ά�����������ֻ��汾��

ɨ��ά����������΢�Ź��ںţ�

��վ�������������������ϴ��������ַ���İ�Ȩ���뷢�ʼ�[email protected]

��ICP��2022002427��-10 �湫��������43070202000427��© 2013~2025 haote.com ������