Go 语言函数/方法重载机制详解与替代方案

type Easy struct {
    curl *C.CURL
    code Code
}

func (e *Easy) SetOption(option Option, param string) {
    e.code = Code(C.curl_wrapper_easy_setopt_str(e.curl, C.CURLoption(option), C.CString(param)))
}

func (e *Easy) SetOption(option Option, param long) { // 编译错误：redeclared in this block
    e.code = Code(C.curl_wrapper_easy_setopt_long(e.curl, C.CURLoption(option), C.long(param)))
}

package main

/*
#include <stdio.h>
#include <stdlib.h>

// 模拟 C 库的 curl_easy_setopt 及其包装函数
typedef int CURLoption;
typedef void CURL; // 简化，实际是 struct CURL

void curl_wrapper_easy_setopt_str(CURL *curl, CURLoption option, char* param) {
    printf("Setting string option %d: %s\n", option, param);
}

void curl_wrapper_easy_setopt_long(CURL *curl, CURLoption option, long param) {
    printf("Setting long option %d: %ld\n", option, param);
}
*/
import "C"
import (
    "fmt"
    "unsafe"
)

// 模拟 Go 语言中的类型
type Option C.CURLoption
type Code int

// Easy 结构体模拟 C.CURL
type Easy struct {
    curl *C.CURL
    code Code
}

// NewEasy 构造函数
func NewEasy() *Easy {
    // 实际项目中这里会初始化 C.CURL
    return &Easy{curl: (*C.CURL)(unsafe.Pointer(uintptr(0)))} // 仅作示例
}

// SetOptionString 用于设置字符串类型的选项
func (e *Easy) SetOptionString(option Option, param string) {
    cParam := C.CString(param)
    defer C.free(unsafe.Pointer(cParam)) // 确保释放 C 字符串内存
    e.code = Code(C.curl_wrapper_easy_setopt_str(e.curl, C.CURLoption(option), cParam))
    fmt.Printf("Go: SetOptionString called with option %v, param \"%s\", result code %d\n", option, param, e.code)
}

// SetOptionLong 用于设置长整型类型的选项
func (e *Easy) SetOptionLong(option Option, param int64) { // Go 中 long 对应 int64
    e.code = Code(C.curl_wrapper_easy_setopt_long(e.curl, C.CURLoption(option), C.long(param)))
    fmt.Printf("Go: SetOptionLong called with option %v, param %d, result code %d\n", option, param, e.code)
}

func main() {
    easy := NewEasy()

    // 示例调用
    easy.SetOptionString(1, "http://example.com")
    easy.SetOptionLong(2, 1024)
}

package main

import "fmt"

// Log 可以接受不同数量和类型的参数
func Log(level string, messages ...interface{}) {
    fmt.Printf("[%s] ", level)
    for _, msg := range messages {
        switch v := msg.(type) {
        case string:
            fmt.Printf("%s ", v)
        case int:
            fmt.Printf("%d ", v)
        case bool:
            fmt.Printf("%t ", v)
        default:
            fmt.Printf("%v ", v) // 处理其他类型
        }
    }
    fmt.Println()
}

func main() {
    Log("INFO", "User logged in:", "admin", 123)
    Log("WARN", "Disk usage high:", 95, "%")
    Log("ERROR", "Failed to connect", true)
    Log("DEBUG", "Raw data:", []byte{0xDE, 0xAD, 0xBE, 0xEF})
}

package main

import "fmt"

// ConnectionOptions 定义了连接的各种可选配置
type ConnectionOptions struct {
    Timeout       int    // 连接超时，单位秒，0表示不设置
    BufferSize    int    // 缓冲区大小，单位字节，0表示默认
    EnableTLS     bool   // 是否启用TLS
    ProxyAddress  string // 代理地址
}

// Connect 接受一个配置结构体，所有选项都是可选的
func Connect(host string, port int, opts *ConnectionOptions) error {
    // 设置默认值
    if opts == nil {
        opts = &ConnectionOptions{} // 如果未提供选项，则使用默认空结构体
    }
    if opts.Timeout == 0 {
        opts.Timeout = 30 // 默认超时30秒
    }
    if opts.BufferSize == 0 {
        opts.BufferSize = 4096 // 默认缓冲区大小4KB
    }

    fmt.Printf("Connecting to %s:%d with options:\n", host, port)
    fmt.Printf("  Timeout: %d seconds\n", opts.Timeout)
    fmt.Printf("  BufferSize: %d bytes\n", opts.BufferSize)
    fmt.Printf("  EnableTLS: %t\n", opts.EnableTLS)
    if opts.ProxyAddress != "" {
        fmt.Printf("  ProxyAddress: %s\n", opts.ProxyAddress)
    } else {
        fmt.Println("  No Proxy")
    }

    // 实际连接逻辑...
    return nil
}

func main() {
    // 1. 使用默认选项连接
    fmt.Println("--- Scenario 1: Default Options ---")
    Connect("example.com", 80, nil)
    fmt.Println()

    // 2. 自定义部分选项
    fmt.Println("--- Scenario 2: Custom Options ---")
    Connect("secure.example.com", 443, &ConnectionOptions{
        Timeout:   60,
        EnableTLS: true,
    })
    fmt.Println()

    // 3. 自定义所有选项
    fmt.Println("--- Scenario 3: All Custom Options ---")
    Connect("proxy.example.com", 8080, &ConnectionOptions{
        Timeout:      10,
        BufferSize:   8192,
        EnableTLS:    false,
        ProxyAddress: "http://myproxy:3128",
    })
}