pointers - 在Go中包装指针

库foo公开了A类型，该库中的函数Fn返回*A。

我为A定义了一个“包装器”，称为B:

type B foo.A

我可以在不取消引用*A的情况下将*B转换为A吗？

换句话说，如果我有

a := foo.Fn()   // a is a *A
b := B(*a)
return &b

如何不使用*a将*b转换为*a？

我问的原因是在我正在使用的库github.com/coreos/bbolt中，从*DB函数返回的Open值包含sync.Mutex，因此当我尝试制作Mutex的副本时，编译器会提示。

更新以说明我将如何使用此

我有一个

type Datastore struct {
    *bolt.DB
}

我也有一个这样的功能(很多):

func (ds *Datastore) ReadOne(bucket, id string, data interface{}) error {
    return ds.View(func(tx *bolt.Tx) error {
        b, err := tx.CreateBucketIfNotExists([]byte(bucket))
        if err != nil {
            return fmt.Errorf("opening bucket %s: %v", bucket, err)
        }

        bytes := b.Get([]byte(id))
        if bytes == nil {
            return fmt.Errorf("id %s not found", id)
        }

        if err := json.Unmarshal(bytes, data); err != nil {
            return fmt.Errorf("unmarshalling item: %v", err)
        }

        return nil
    })
}

我想使用哈希图模拟基础的BoltDB数据库。我遇到了一个模拟此问题的问题，因为View期望使用bolt.Tx的函数。然后使用该tx在CreateBucketIfNotExists中创建一个新存储桶。我无法用调用我的哈希映射模拟版本CreateBucketIfNotExists的匿名函数参数替换该参数。

我想出了这个:

package boltdb

import (
    "github.com/coreos/bbolt"
)

type (
    bucket bolt.Bucket

    // Bucket is a wrapper for bolt.Bucket to facilitate mocking.
    Bucket interface {
        ForEach(fn func([]byte, []byte) error) error
        Get(key []byte) []byte
        NextSequence() (uint64, error)
        Put(key, value []byte) error
    }

    db bolt.DB

    // DB is a wrapper for bolt.DB to facilitate mocking.
    DB interface {
        Close() error
        Update(fn func(*Tx) error) error
        View(fn func(*Tx) error) error
    }

    transaction bolt.Tx

    // Tx is a wrapper for bolt.Tx to facilitate mocking.
    Tx interface {
        CreateBucketIfNotExists(name []byte) (Bucket, error)
    }
)

// ForEach executes a function for each key/value pair in a bucket.
func (b *bucket) ForEach(fn func([]byte, []byte) error) error {
    return ((*bolt.Bucket)(b)).ForEach(fn)
}

// Get retrieves the value for a key in the bucket.
func (b *bucket) Get(key []byte) []byte {
    return ((*bolt.Bucket)(b)).Get(key)
}

// NextSequence returns an autoincrementing integer for the bucket.
func (b *bucket) NextSequence() (uint64, error) {
    return ((*bolt.Bucket)(b)).NextSequence()
}

// Put sets the value for a key in the bucket.
func (b *bucket) Put(key, value []byte) error {
    return ((*bolt.Bucket)(b)).Put(key, value)
}

// Close releases all database resources.
func (db *db) Close() error {
    return ((*bolt.DB)(db)).Close()
}

// Update executes a function within the context of a read-write managed transaction.
func (db *db) Update(fn func(Tx) error) error {
    return ((*bolt.DB)(db)).Update(func(tx *bolt.Tx) error {
        t := transaction(*tx)
        return fn(&t)
    })
}

// View executes a function within the context of a managed read-only transaction.
func (db *db) View(fn func(Tx) error) error {
    return ((*bolt.DB)(db)).View(func(tx *bolt.Tx) error {
        t := transaction(*tx)
        return fn(&t)
    })
}

// CreateBucketIfNotExists creates a new bucket if it doesn't already exist.
func (tx *transaction) CreateBucketIfNotExists(name []byte) (Bucket, error) {
    b, err := ((*bolt.Tx)(tx)).CreateBucketIfNotExists(name)
    if err != nil {
        return nil, err
    }
    w := bucket(*b)
    return &w, nil
}

到目前为止，在我的代码中，我仅使用上面显示的功能。如果需要新代码，我可以添加更多。

我将在实际代码中将每个bolt.DB替换为DB，将bolt.Tx替换为Tx，将bolt.Bucket替换为Bucket。该模拟程序将对使用基础哈希映射的所有三种类型使用替换，而不是存储到磁盘。然后，我可以测试所有代码，直到数据库调用为止。

最佳答案

您可以简单地/直接将*A类型的值转换为*B类型的值，只需括号内*B即可:

a := foo.Fn()   // a is a *A
b := (*B)(a)
return b

您甚至可以转换函数调用的返回值:

return (*B)(foo.Fn())

在Go Playground上尝试一下。
这是可能的，因为Spec: Conversions:

和Spec: Assignability:
*B和*A类型均未定义，并且*B的基础类型与*A的基础类型相同(这是指向A类型声明中任何类型的基础类型的指针)。

关于pointers - 在Go中包装指针，我们在Stack Overflow上找到一个类似的问题：https://stackoverflow.com/questions/48867312/