생각하는 Go 언어 프로그래밍 : 구조체에 생성자를 둘 수 있나?

// 온도를 나타내는 값 타입
type Temperature struct {  // ❶ 값 타입
    Value int
    Type string
}

// 온도 객체 생성
func NewTemperature(v int, t string) Temperature { // ❷ 값 타입 생성
    return Temperature{ Value: v, Type: t }
}

// 온도 증가
func (t Temperature) Add(v int) Temperature { // ❸ 값 타입 메서드
    return Temperature{ Value: t.Value + v, Type: t.Type }
}

// 학생을 나타내는 포인터
type Student struct {  // ❹ 포인터
    Age int
    Name string 
}

// 새로운 학생 생성
func NewStudent(age int, name string) *Student { // ❺ 포인터 생성
      return &Student{ Age: age, Name: name }
}

// 나이 증가
func (s *Student) AddAge(a int) { // ❻ 포인터 메서드
    s.Age += a
}

type Time
    func Now() Time // ❶ 현재 시각을 나타내는 Time 반환 
    func (t Time) Add(d Duration) Time
    func (t Time) AddDate(years int, months int, days int) Time
    func (t Time) After(u Time) bool

type Timer
     func AfterFunc(d Duration, f func()) *Timer
     func NewTimer(d Duration) *Timer
     func (t *Timer) Reset(d Duration) bool
     func (t *Timer) Stop() bool

package marketplace

import "item"

type Marketplace struct {
}

func NewMarketplace() *Marketplace {
     ...
}

func (m *Marketplace) PurchaseItem() *item.Item {
     ...
}

package main
 import (
     "item"
     "marketplace"
 )

 func main() {
      mp := marketplace.NewMarketplace()
      mp.PurchaseItem()
      ...
}

package marketplaceV2

import "item"

type MarketplaceV2 struct {
}

func NewMarketplace() *MarketplaceV2 {
     ...
}

func (m *MarketplaceV2) PurchaseItem() *item.Item {
     ...
}

package main

import (
    "item"
    "marketplaceV2"
)

type ItemPurchaser {  // 인터페이스 정의
    PurchaseItem() *item.Item
}

func main() {
    var purchaser ItemPurchaser
    purchaser = marketplaceV2.NewMarketplace() // ❶
    purchaser.PurchaseItem()
    ...
}

type Student struct {
    name string
    age int
    group *Group
}

var student Student

package main

import "fmt"

func main() {
    var slice []int // ❶ 0개 cap을 갖는 슬라이스
    
    slice, allocCnt := append1000times(slice)
    fmt.Println("allocCnt:", allocCnt, "cap:", cap(slice))

    var slice2 = make([]int, 0, 1000) // ❷ 1000개 cap을 갖는 슬라이스
    slice, allocCnt = append1000times(slice2)
    fmt.Println("allocCnt:", allocCnt, "cap:", cap(slice))
}

func append1000times(slice []int) ([]int, int) {
    var lastCap int = cap(slice)
    var allocCnt int = 0
    for i := 0; i < 1000; i++ {
        slice = append(slice, i)
        if lastCap != cap(slice) { // ❸ capacity가 바뀔 때 allocCnt 증가
            allocCnt++
            lastCap = cap(slice)
        }
    }
    return slice, allocCnt
 }

package main

import "fmt"

func main() {
    fac := NewFlyweightFactory(1000) // ❶ 객체 공장
    for i := 0; i < 1000; i++ {
        obj := fac.Create() // ❷ 1000번 만들고 버립니다. 
        obj.Somedata = "Somedata"
        fac.Dispose(obj)
    }
    fmt.Println("AllocCnt:", fac.AllocCnt)
}

type FlyweightFactory struct {
    pool     []*Flyweight
    AllocCnt int
}

func (fac *FlyweightFactory) Create() *Flyweight {
    var obj *Flyweight
    if len(fac.pool) > 0 { // ❸ 재활용
        obj, fac.pool = fac.pool[len(fac.pool)-1], fac.pool[:len(fac.pool)-1]
        obj.Reuse()
    } else {
        obj = &Flyweight{}  // ❹ 새로 만듭니다.
        fac.AllocCnt++
    }
return obj 
}

func (fac *FlyweightFactory) Dispose(obj *Flyweight) { // ❺ 반환
    obj.Dispose()
    fac.pool = append(fac.pool, obj)
}

func NewFlyweightFactory(initSize int) *FlyweightFactory {
    return &FlyweightFactory{pool: make([]*Flyweight, 0, initSize)}
}

type Flyweight struct {
    Somedata   string
    isDisposed bool
}
func (f *Flyweight) Reuse() {
    f.isDisposed = false
}

func (f *Flyweight) Dispose() {
    f.isDisposed = true
}

func (f *Flwweight) IsDisposed() bool {
    return f.isDisposed
}

go test -cpuprofile cpu.prof -memprofile mem.prof –bench .

func Sort(data sort.Interface)

type Interface interface {
    Len() int  // 길이 반환
    Less(i, j int) bool  // i번째와 j번째 비교 
    Swap(i, j int)  // i번째와 j번째 바꿈
}

s := []int{5, 2, 6, 3, 1, 4}
sort.Sort(sort.IntSlice(s))

type IntSlice []int // ❶ []int 별칭 타입

func (p IntSlice) Len() int { return len(p) } // ❷ 길이 반환 
func (p IntSlice) Less(i, j int) bool { return p[i] < p[j] } // ❸ 비교 결과 반환 
func (p IntSlice) Swap(i, j int) { p[i], p[j] = p[j], p[i] } // ❹ 값 바꾸기