ドキュメント価格ブログ
お問い合わせ
ログイン無料で新規登録
Back to Tech Articles

Goの構造体への飛び込み

Jan 02, 2025
# go

Daniel Hayes

Full-Stack Engineer · Leapcell

この記事はEnglish、한국어、Deutschでも利用できます
Cover of "Goの構造体への飛び込み"

Goでは、structはデータの定義とカプセル化に使用される集約型です。異なる型のフィールドを組み合わせることができます。構造体は、他の言語のクラスに似たカスタムデータ型と見なすことができますが、継承はサポートしていません。メソッドは、特定の型（多くの場合、構造体）に関連付けられた関数であり、その型のインスタンスを使用して呼び出すことができます。

構造体の定義と初期化

構造体の定義

構造体は、typeおよびstructキーワードを使用して定義されます。以下は、単純な構造体定義の例です。

type User struct {
  Username    string
  Email       string
  SignInCount int
  IsActive    bool
}

構造体の初期化

構造体はさまざまな方法で初期化できます。

フィールド名を使用した初期化

user1 := User{
  Username:    "alice",
  Email:       "alice@example.com",
  SignInCount: 1,
  IsActive:    true,
}

デフォルト値を使用した初期化

一部のフィールドが指定されていない場合、それらはそれぞれの型のゼロ値に初期化されます。

user2 := User{
  Username: "bob",
}

この例では、Emailは空の文字列（""）に、SignInCountは0に、IsActiveはfalseに初期化されます。

ポインタを使用した初期化

構造体は、ポインタを使用して初期化することもできます。

user3 := &User{
  Username: "charlie",
  Email:    "charlie@example.com",
}

構造体のメソッドと動作

Goでは、構造体はデータを格納するだけでなく、それに対して定義されたメソッドを持つことができます。これにより、構造体はデータに関連する動作をカプセル化できます。以下は、構造体メソッドと動作の詳細な説明です。

構造体のメソッドの定義

メソッドはレシーバーを使用して定義されます。レシーバーはメソッドの最初のパラメータであり、メソッドが属する型を指定します。レシーバーは、値レシーバーまたはポインタレシーバーのいずれかです。

値レシーバー

値レシーバーは、メソッドが呼び出されたときに構造体のコピーを作成するため、フィールドの変更は元の構造体に影響を与えません。

type User struct {
  Username string
  Email    string
}

func (u User) PrintInfo() {
  fmt.Printf("Username: %s, Email: %s\n", u.Username, u.Email)
}

ポインタレシーバー

ポインタレシーバーを使用すると、メソッドは元の構造体フィールドを直接変更できます。

func (u *User) UpdateEmail(newEmail string) {
  u.Email = newEmail
}

メソッドセット

Goでは、構造体のすべてのメソッドがそのメソッドセットを形成します。値レシーバーのメソッドセットには、値レシーバーを持つすべてのメソッドが含まれ、ポインタレシーバーのメソッドセットには、ポインタと値の両方のレシーバーを持つすべてのメソッドが含まれます。

インターフェースと構造体メソッド

構造体メソッドは、ポリモーフィズムを実現するためにインターフェースでよく使用されます。インターフェースを定義するときは、構造体が実装する必要があるメソッドを指定します。

type UserInfo interface {
  PrintInfo()
}

// User implements the UserInfo interface
func (u User) PrintInfo() {
  fmt.Printf("Username: %s, Email: %s\n", u.Username, u.Email)
}

func ShowInfo(ui UserInfo) {
  ui.PrintInfo()
}

構造体のメモリアライメント

Goでは、構造体のメモリアライメントは、アクセス効率を向上させるように設計されています。異なるデータ型には特定のアライメント要件があり、コンパイラはこれらの要件を満たすために構造体フィールド間にパディングバイトを挿入する場合があります。

メモリアライメントとは？

メモリアライメントとは、メモリ内のデータが特定のmultipleのアドレスにある必要があることを意味します。データ型のサイズによって、そのアライメント要件が決まります。たとえば、int32は4バイトのアライメントが必要で、int64は8バイトのアライメントが必要です。

メモリアライメントが必要な理由

効率的なメモリアクセスは、CPUパフォーマンスにとって非常に重要です。変数が正しくアライメントされていない場合、CPUはデータを読み書きするために複数回のメモリアクセスが必要になる場合があり、パフォーマンスが低下します。データをアライメントすることにより、コンパイラは効率的なメモリアクセスを保証します。

構造体メモリアライメントのルール

  • フィールドアライメント: 各フィールドのアドレスは、その型のアライメント要件を満たす必要があります。コンパイラは、適切なアライメントを確保するために、フィールド間にパディングバイトを挿入する場合があります。
  • 構造体アライメント: 構造体のサイズは、そのフィールドの中で最大のアライメント要件の倍数である必要があります。

例：

package main

import (
  "fmt"
  "unsafe"
)

type Example struct {
  a int8   // 1 byte
  b int32  // 4 bytes
  c int8   // 1 byte
}

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

出力：12

分析:

  • aはint8で、1バイトを占有し、1にアライメントされます。
  • bはint32で、4バイトのアライメントが必要です。コンパイラは、bのアドレスを4にアライメントするために、aとbの間に3つのパディングバイトを挿入します。
  • cはint8で、1バイトが必要ですが、構造体の合計サイズは4（最大のアライメント要件）の倍数である必要があります。コンパイラは最後に3つのパディングバイトを追加します。

メモリアライメントの最適化

構造体フィールドを再配置して、パディングを最小限に抑え、メモリ使用量を削減できます。

type Optimized struct {
  b int32  // 4 bytes
  a int8   // 1 byte
  c int8   // 1 byte
}

出力：8

この最適化されたバージョンでは、bが最初に配置され、4バイトにアライメントされます。aとcは連続して配置され、合計サイズは8バイトになり、最適化されていないバージョンよりもコンパクトになります。

まとめ

  • Goの構造体フィールドは、そのアライメント要件に基づいてメモリが割り当てられ、潜在的なパディングバイトが使用されます。
  • フィールドの順序を調整すると、パディングを最小限に抑え、メモリ使用量を最適化できます。
  • unsafe.Sizeofを使用して、構造体の実際のメモリサイズを決定します。

ネストされた構造体とコンポジション

Goでは、ネストされた構造体とコンポジションは、コードの再利用と複雑なデータの整理に役立つ強力なツールです。ネストされた構造体を使用すると、構造体が別の構造体をフィールドとして含めることができ、複雑なデータモデルを作成できます。一方、コンポジションは、他の構造体を含めることによって新しい構造体を作成し、コードの再利用を促進します。

ネストされた構造体

ネストされた構造体を使用すると、1つの構造体が別の構造体をフィールドとして含めることができます。これにより、データ構造がより柔軟になり、整理されます。以下は、ネストされた構造体の例です。

package main

import "fmt"

// Address構造体を定義します
type Address struct {
  City    string
  Country string
}

// User構造体を定義します。これには、Address構造体が含まれます
type User struct {
  Username string
  Email    string
  Address  Address // ネストされた構造体
}

func main() {
  // ネストされた構造体を初期化します
  user := User{
    Username: "alice",
    Email:    "alice@example.com",
    Address: Address{
      City:    "New York",
      Country: "USA",
    },
  }

  // ネストされた構造体のフィールドにアクセスします
  fmt.Printf("User: %s, Email: %s, City: %s, Country: %s\n", user.Username, user.Email, user.Address.City, user.Address.Country)
}

構造体コンポジション

コンポジションを使用すると、複数の構造体を組み合わせて新しい構造体を作成し、コードを再利用できます。コンポジションでは、構造体は複数の他の構造体をフィールドとして含めることができます。これにより、より複雑なモデルを構築し、共通のフィールドまたはメソッドを共有できます。以下は、構造体コンポジションの例です。

package main

import "fmt"

// Address構造体を定義します
type Address struct {
  City    string
  Country string
}

// Profile構造体を定義します
type Profile struct {
  Age int
  Bio string
}

// User構造体を定義します。これは、AddressとProfileを構成します
type User struct {
  Username string
  Email    string
  Address  Address // Address構造体を構成します
  Profile  Profile // Profile構造体を構成します
}

func main() {
  // 構成された構造体を初期化します
  user := User{
    Username: "bob",
    Email:    "bob@example.com",
    Address: Address{
      City:    "New York",
      Country: "USA",
    },
    Profile: Profile{
      Age: 25,
      Bio: "A software developer.",
    },
  }

  // 構成された構造体のフィールドにアクセスします
  fmt.Printf("User: %s, Email: %s, City: %s, Age: %d, Bio: %s\n", user.Username, user.Email, user.Address.City, user.Profile.Age, user.Profile.Bio)
}

ネストされた構造体とコンポジションの違い

  • ネストされた構造体: 構造体を一緒に結合するために使用されます。ここでは、ある構造体のフィールドの型が別の構造体です。このアプローチは、階層的な関係を持つデータモデルを記述するためによく使用されます。
  • コンポジション: 複数の他の構造体からフィールドを構造体に含めることができます。このメソッドは、コードの再利用を実現するために使用され、構造体がより複雑な動作と属性を持つことを可能にします。

まとめ

ネストされた構造体とコンポジションは、複雑なデータ構造を整理および管理するのに役立つGoの強力な機能です。データモデルを設計する際には、ネストされた構造体とコンポジションを適切に使用すると、コードがより明確になり、保守が容易になります。

空の構造体

Goの空の構造体とは、フィールドを持たない構造体のことです。

サイズとメモリアドレス

空の構造体は、ゼロバイトのメモリを占有します。ただし、そのメモリアドレスは、状況によって等しい場合と等しくない場合があります。メモリエスケープが発生すると、アドレスは等しくなり、runtime.zerobaseを指します。

// empty_struct.go
type Empty struct{}

//go:linkname zerobase runtime.zerobase
var zerobase uintptr // go:linknameディレクティブを使用して、zerobaseをruntime.zerobaseにリンクします

func main() {
  a := Empty{}
  b := struct{}{}

  fmt.Println(unsafe.Sizeof(a) == 0) // true
  fmt.Println(unsafe.Sizeof(b) == 0) // true
  fmt.Printf("%p\n", &a)             // 0x590d00
  fmt.Printf("%p\n", &b)             // 0x590d00
  fmt.Printf("%p\n", &zerobase)      // 0x590d00

  c := new(Empty)
  d := new(Empty) // cとdを強制的にエスケープさせます
  fmt.Sprint(c, d)
  println(c)   // 0x590d00
  println(d)   // 0x590d00
  fmt.Println(c == d) // true

  e := new(Empty)
  f := new(Empty)
  println(e)   // 0xc00008ef47
  println(f)   // 0xc00008ef47
  fmt.Println(e == f) // false
}

出力から、変数a、b、およびzerobaseは同じアドレスを共有し、すべてグローバル変数runtime.zerobase（runtime/malloc.go）を指しています。

エスケープのシナリオについて:

  • 変数cとdはヒープにエスケープします。アドレスは0x590d00で、等しい（true）と比較されます。
  • 変数eとfは異なるアドレス（0xc00008ef47）を持ち、等しくない（false）と比較されます。

この動作はGoでは意図的なものです。空の構造体変数がエスケープしない場合、それらのポインタは等しくありません。エスケープ後、ポインタは等しくなります。

空の構造体を埋め込む場合のスペース計算

空の構造体自体はスペースを占有しませんが、別の構造体に埋め込まれている場合、その位置に応じてスペースを消費する可能性があります。

  • 構造体内の唯一のフィールドである場合、構造体はスペースを占有しません。
  • 最初または中間のフィールドである場合、スペースを占有しません。
  • 最後のフィールドである場合、前のフィールドと同じスペースを占有します。
type s1 struct {
  a struct{}
}

type s2 struct {
  _ struct{}
}

type s3 struct {
  a struct{}
  b byte
}

type s4 struct {
  a struct{}
  b int64
}

type s5 struct {
  a byte
  b struct{}
  c int64
}

type s6 struct {
  a byte
  b struct{}
}

type s7 struct {
  a int64
  b struct{}
}

type s8 struct {
  a struct{}
  b struct{}
}

func main() {
  fmt.Println(unsafe.Sizeof(s1{})) // 0
  fmt.Println(unsafe.Sizeof(s2{})) // 0
  fmt.Println(unsafe.Sizeof(s3{})) // 1
  fmt.Println(unsafe.Sizeof(s4{})) // 8
  fmt.Println(unsafe.Sizeof(s5{})) // 16
  fmt.Println(unsafe.Sizeof(s6{})) // 2
  fmt.Println(unsafe.Sizeof(s7{})) // 16
  fmt.Println(unsafe.Sizeof(s8{})) // 0
}

空の構造体が配列またはスライスの要素である場合：

var a [10]int
fmt.Println(unsafe.Sizeof(a)) // 80

var b [10]struct{}
fmt.Println(unsafe.Sizeof(b)) // 0

var c = make([]struct{}, 10)
fmt.Println(unsafe.Sizeof(c)) // 24, スライスヘッダーのサイズ

アプリケーション

空の構造体のゼロサイズプロパティにより、余分なメモリオーバーヘッドなしで、さまざまな目的に使用できます。

キーなし構造体の初期化の防止

type MustKeyedStruct struct {
  Name string
  Age  int
  _    struct{}
}

func main() {
  person := MustKeyedStruct{Name: "hello", Age: 10}
  fmt.Println(person)

  person2 := MustKeyedStruct{"hello", 10} // コンパイルエラー：MustKeyedStruct{...}の値が少なすぎます
  fmt.Println(person2)
}

セットデータ構造の実装

package main

import (
  "fmt"
)

type Set struct {
  items map[interface{}]emptyItem
}

type emptyItem struct{}

var itemExists = emptyItem{}

func NewSet() *Set {
  return &Set{items: make(map[interface{}]emptyItem)}
}

func (set *Set) Add(item interface{}) {
  set.items[item] = itemExists
}

func (set *Set) Remove(item interface{}) {
  delete(set.items, item)
}

func (set *Set) Contains(item interface{}) bool {
  _, contains := set.items[item]
  return contains
}

func (set *Set) Size() int {
  return len(set.items)
}

func main() {
  set := NewSet()
  set.Add("hello")
  set.Add("world")
  fmt.Println(set.Contains("hello"))
  fmt.Println(set.Contains("Hello"))
  fmt.Println(set.Size())
}

チャネルを介した信号伝送

チャネルを介して送信されるデータの内容が、単なる信号として機能し、無関係な場合があります。たとえば、空の構造体はセマフォの実装で使用できます。

var empty = struct{}{}

type Semaphore chan struct{}

func (s Semaphore) P(n int) {
  for i := 0; i < n; i++ {
    s <- empty
  }
}

func (s Semaphore) V(n int) {
  for i := 0; i < n; i++ {
    <-s
  }
}

func (s Semaphore) Lock() {
  s.P(1)
}

func (s Semaphore) Unlock() {
  s.V(1)
}

func NewSemaphore(N int) Semaphore {
  return make(Semaphore, N)
}

私たちLeapcellは、Goプロジェクトをクラウドにデプロイするための最適な選択肢です。

Leapcell

Leapcellは、Webホスティング、非同期タスク、Redis向けの次世代サーバーレスプラットフォームです。

  1. 多言語サポート
  • JavaScript、Python、Go、またはRustで開発します。
  1. 無制限のプロジェクトを無料でデプロイ
  • 使用量のみを支払い — リクエストも料金もありません。
  1. 比類のないコスト効率
  • アイドル料金なしの従量課金制。
  • 例：25ドルで、平均応答時間60msで694万リクエストをサポートします。
  1. 合理化された開発者エクスペリエンス
  • 簡単なセットアップのための直感的なUI。
  • 完全に自動化されたCI/CDパイプラインとGitOpsの統合。
  • 実用的な洞察を得るためのリアルタイムメトリックとロギング。
  1. 容易なスケーラビリティとハイパフォーマンス
  • 高い同時実行性を簡単に処理するための自動スケーリング。
  • 運用上のオーバーヘッドはゼロ — 構築に集中するだけです。

詳細については、ドキュメント！をご覧ください。

Xでフォローしてください：@LeapcellHQ

Share this article

HackerNews

More Posts from Leapcell

cover

2024年を振り返る：クラウドデータベースのキーハイライト

cover

Express.jsをマスター：深い探求

Popular Posts