golang,c#函数传参 和 c++函数传参的区别

先看c#的

public static void getFileName(StreamWriter sw, string path, int indent, List<string> listFile)
{
    DirectoryInfo root = new System.IO.DirectoryInfo(path);
    foreach (FileInfo f in root.GetFiles())
    {
        listFile.Add(f.Name);
        Log.Debug(f.Name);
    }
}

List<string> listFile = new List<string>();
FileHandle.getFileName(sw, facePic, 2, listFile);
foreach (string p in listFile)
{
	Log.Debug(p);
}

这里我们使用listFile变量 new了一个对象，传参给函数getFileName中的 listfile.在该函数中处理完，返回，然后在该函数外边再打印listFile变量的值，发现跟函数里面是一样的，这说明是同一个对象。其实这里隐藏了指针。

再来看c++代码，如果要实现上边的效果，该怎么写？

void getFileName(StreamWriter sw, string path, int indent, List<string> *listFile)
{
    DirectoryInfo root = new System.IO.DirectoryInfo(path);
    foreach (FileInfo f in root.GetFiles())
    {
        listFile->Add(f.Name);
        Log.Debug(f.Name);
    }
}

List<string> *listFile = new List<string>();
FileHandle.getFileName(sw, facePic, 2, listFile);
foreach (string p in listFile)
{
	Log.Debug(p);
}

这里我没有严格按照c++的list标准写法去写，主要是修改了在c++里如果要实现上边c#的效果该怎么做，首先需要表明listFile是一个指针，new该对象。然后修改函数里参数listFile也为指针，传参给函数调用。listFile->指针要使用->。最后返回出来的结果才是listFile同一个指针对象。

那么如果c++也像c#那样写，会有什么结果呢？

void getFileName(StreamWriter sw, string path, int indent, List<string> listFile)
{
    DirectoryInfo root = new System.IO.DirectoryInfo(path);
    foreach (FileInfo f in root.GetFiles())
    {
        listFile.Add(f.Name);
        Log.Debug(f.Name);
    }
}

List<string> listFile;// = new List<string>();
FileHandle.getFileName(sw, facePic, 2, listFile);

foreach (string p in listFile)
{
//此处打印一个也没有，将是0
	Log.Debug(p);
}

结果就是在函数调用外边得不到和函数里面相同的结果，因为是两个对象。当我们向函数传参listFile时，此时在函数里面已经产生了一个新的listFile对象，跟传进的参数一模一样，但是他们的地址不一样。我们在函数里操作listfile对象，并没有操作我们函数外边那个传参的listFile对象。这显然不是我们想要的。所以c++使用指针指明内存地址操作的是哪一个对象。

golang

https://segmentfault.com/a/1190000012325027

使用中如果包含数组，结构体的实例化需要加上类型如上如果intro的类型是[]string。

加&符号和new的是指针对象，没有的则是值对象，这点和php、java不一致，在传递对象的时候要根据实际情况来决定是要传递指针还是值。

tips：当对象比较小的时候传递指针并不划算。

构造函数(自己创造)

package main

import (
	"context"
	"fmt"
	"log"
	"runtime"

	//"github.com/sbinet/go-python"
	"golang.org/x/sync/semaphore"
)

// func init() {
// 	err := python.Initialize()
// 	if err != nil {
// 		panic(err.Error())
// 	}
// }

// var PyStr = python.PyString_FromString
// var GoStr = python.PyString_AS_STRING

// func vals() (int, int) {
// 	return 3, 7
// }

// collatzSteps computes the number of steps to reach 1 under the Collatz
// conjecture. (See https://en.wikipedia.org/wiki/Collatz_conjecture.)
func collatzSteps(n int) (steps int) {
	if n <= 0 {
		panic("nonpositive input")
	}

	for ; n > 1; steps++ {
		if steps < 0 {
			panic("too many steps")
		}

		if n%2 == 0 {
			n /= 2
			continue
		}

		const maxInt = int(^uint(0) >> 1)
		if n > (maxInt-1)/3 {
			panic("overflow")
		}
		n = 3*n + 1
	}

	return steps
}

type Poem struct {
	Title  string
	Author string
	intro  string
}

func NewPoem(author string) (poem *Poem) {
	poem = &Poem{}
	poem.Author = author
	return
}

func (e *Poem) ShowTitle() {
	fmt.Printf(e.Title)
}

// type Poem struct {
//     Title  string
//     Author string
//     intro  string
// }

type ProsePoem struct {
	Poem
	Author string
}

type Father struct {
	MingZi string
}

func (this *Father) Say() string {
	return "大家好，我叫 " + this.MingZi
}

type Mother struct {
	Name string
}

func (this *Mother) Say() string {
	return "Hello, my name is " + this.Name
}

type Child struct {
	Father
	Mother
}

func (poem *Poem) recite(v ...interface{}) {

	fmt.Println(v[0])
}

func main() {

	// prosePoem := &ProsePoem{}
	// prosePoem.Author = "Heine"

	// prosePoem := &ProsePoem{
	// 	Poem: Poem{
	// 		Title:  "Jack",
	// 		Author: "slow",
	// 		intro:  "simple",
	// 	},
	// 	Author: "test",
	// }

	c := new(Child)
	c.MingZi = "张小明"
	c.Name = "Tom Zhang"

	c.Father.Say()
	c.Mother.Say()

	prosePoem := &ProsePoem{}
	prosePoem.recite("ni", 2, 3)

	prosePoem.Author = "Shelley"

	prosePoem.Poem.Author = "Heine"

	fmt.Println(prosePoem)

	poem6 := NewPoem("Heine")

	p := struct {
		Name   string
		Gender string
		Age    uint8
	}{"Robert", "Male", 33}

	fmt.Printf("%v, poem6: %v, prosePoem: %v", p, poem6, prosePoem)

	poem := &Poem{}

	poem.Author = "Heine"

	poem2 := &Poem{Author: "Heine"}

	poem3 := new(Poem)

	poem3.Author = "Heine"

	poem4 := Poem{}

	poem4.Author = "Heine"

	poem5 := Poem{Author: "Heine"}

	// p1 := &Poem{
	//     "zhangsan",
	//     25,
	//     []string{"lisi", "wangwu"},
	// }

	fmt.Printf("poem2: %v, poem5: %v", poem2, poem5)

	ctx := context.TODO()

	// 权重值为逻辑cpu个数
	var (
		maxWorkers = runtime.GOMAXPROCS(0)
		sem        = semaphore.NewWeighted(int64(maxWorkers))
		out        = make([]int, 32)
	)

	// Compute the output using up to maxWorkers goroutines at a time.
	for i := range out {
		// When maxWorkers goroutines are in flight, Acquire blocks until one of the
		// workers finishes.
		if err := sem.Acquire(ctx, 1); err != nil {
			log.Printf("Failed to acquire semaphore: %v", err)
			break
		}

		go func(i int) {
			defer sem.Release(1)
			out[i] = collatzSteps(i + 1)
		}(i)
	}

	// 如果使用了 errgroup 原语则不需要下面这段语句
	if err := sem.Acquire(ctx, int64(maxWorkers)); err != nil {
		log.Printf("Failed to acquire semaphore: %v", err)
	}

	fmt.Println(out)

	// array := [5]int{1, 2, 3, 4, 5}
	// s := []int{1, 2, 3}
	// var a2 string = "Runoob"

	//a11, b11 := vals()
	//a11 := vals()

	//	fmt.Printf("array: %v, s: %v, a: %v, a11: %v, b11: %v\n", array, s, a2, a11, b11)

	// import hello
	//InsertBeforeSysPath("/Users/vonng/anaconda2/lib/python2.7/site-packages")
	// InsertBeforeSysPath("/usr/local/lib/python2.7/site-packages")

	// m := python.PyImport_ImportModule("sys")
	// if m == nil {
	// 	fmt.Println("import error")
	// 	return
	// }
	// path := m.GetAttrString("path")
	// if path == nil {
	// 	fmt.Println("get path error")
	// 	return
	// }
	// //加入当前目录，空串表示当前目录
	// //currentDir := python.PyString_FromString("")
	// currentDir := python.PyString_FromString("/home/test/python/test")
	// python.PyList_Insert(path, 0, currentDir)

	// m = python.PyImport_ImportModule("fib") //加载python的模块，文件名
	// if m == nil {
	// 	fmt.Println("import error")
	// 	return
	// }
	// fib := m.GetAttrString("fib") //加载python的方法
	// if fib == nil {
	// 	fmt.Println("get fib error")
	// 	return
	// }
	// out := fib.CallFunction(python.PyInt_FromLong(10)) //调用python的方法，并传参
	// if out == nil {
	// 	fmt.Println("call fib error")
	// 	return
	// }
	// fmt.Printf("fib(%d)=%d\n", 10, python.PyInt_AsLong(out))

	// //	hello := ImportModule("/Users/vonng/Dev/go/src/gitlab.alibaba-inc.com/cplus", "hello")
	// hello := ImportModule("/home/test/python/test", "test1")
	// if hello == nil {
	// 	fmt.Println("import error")
	// 	return
	// }
	// fmt.Printf("[MODULE] repr(hello) = %s\n", GoStr(hello.Repr()))

	// // print(hello.a)
	// a := hello.GetAttrString("VM_NAMESPACE")
	// SERVICE_ACCOUNT := hello.GetAttrString("SERVICE_ACCOUNT")
	// VM_APP := hello.GetAttrString("VM_APP")

	// //fmt.Printf("[VARS] a = %#v\n", python.PyInt_AsLong(a))
	// fmt.Printf("[VARS] a = %#v, SERVICE_ACCOUNT= %#v, VM_APP=%#v\n", python.PyString_AsString(a),
	// 	python.PyString_AsString(SERVICE_ACCOUNT), python.PyString_AsString(VM_APP))

	// b := hello.GetAttrString("b")
	// fmt.Printf("[FUNC] b = %#v\n", b)

	// // args = tuple("xixi",)
	// bArgs := python.PyTuple_New(1)
	// python.PyTuple_SetItem(bArgs, 0, PyStr("xixiddd"))

	// // b(*args)
	// res := b.Call(bArgs, python.Py_None)
	// fmt.Printf("[CALL] b('xixi') = %s\n", GoStr(res))

	// // print(hello.b)
	// init := hello.GetAttrString("init")
	// fmt.Printf("[FUNC] b = %#v\n", init)

	// // args = tuple("xixi",)
	// bArgs = python.PyTuple_New(7)
	// //    init("vm3", "vmsrv3", "vmapp1", "./work", "Kubernetes", "", "")
	// python.PyTuple_SetItem(bArgs, 0, PyStr("vm3"))
	// python.PyTuple_SetItem(bArgs, 1, PyStr("vmsrv3"))
	// python.PyTuple_SetItem(bArgs, 2, PyStr("vmapp3"))
	// python.PyTuple_SetItem(bArgs, 3, PyStr("./work"))
	// python.PyTuple_SetItem(bArgs, 4, PyStr("Kubernetes"))
	// python.PyTuple_SetItem(bArgs, 5, PyStr(""))
	// python.PyTuple_SetItem(bArgs, 6, PyStr(""))

	// // b(*args)    , SERVICE_ACCOUNT, VM_APP, WORK_DIR, CLUSTER, VM_NETWORK, CLUSTER_NETWORK
	// VM_NAMESPACE := init.Call(bArgs, python.Py_None)
	// fmt.Printf("[CALL] init() = %v\n", VM_NAMESPACE)
	// // fmt.Printf("[CALL] init() = %s, %s\n", GoStr(VM_NAMESPACE), GoStr(SERVICE_ACCOUNT), GoStr(VM_APP), GoStr(WORK_DIR),
	// // 	GoStr(CLUSTER), GoStr(VM_NETWORK), GoStr(CLUSTER_NETWORK))

	// a = hello.GetAttrString("VM_NAMESPACE")
	// SERVICE_ACCOUNT = hello.GetAttrString("SERVICE_ACCOUNT")
	// VM_APP = hello.GetAttrString("VM_APP")
	// fmt.Printf("[VARS] a = %#v, SERVICE_ACCOUNT= %#v, VM_APP=%#v\n", python.PyString_AsString(a),
	// 	python.PyString_AsString(SERVICE_ACCOUNT), python.PyString_AsString(VM_APP))

	// // sklearn
	// sklearn := hello.GetAttrString("sklearn")
	// skVersion := sklearn.GetAttrString("__version__")
	// fmt.Printf("[IMPORT] sklearn = %s\n", GoStr(sklearn.Repr()))
	// fmt.Printf("[IMPORT] sklearn version =  %s\n", GoStr(skVersion.Repr()))
}

// // InsertBeforeSysPath will add given dir to python import path
// func InsertBeforeSysPath(p string) string {
// 	sysModule := python.PyImport_ImportModule("sys")
// 	path := sysModule.GetAttrString("path")
// 	python.PyList_Insert(path, 0, PyStr(p))
// 	return GoStr(path.Repr())
// }

// // ImportModule will import python module from given directory
// func ImportModule(dir, name string) *python.PyObject {
// 	sysModule := python.PyImport_ImportModule("sys") // import sys
// 	path := sysModule.GetAttrString("path")          // path = sys.path
// 	python.PyList_Insert(path, 0, PyStr(dir))        // path.insert(0, dir)
// 	return python.PyImport_ImportModule(name)        // return __import__(name)
// }

// package main

// import (
// 	"fmt"

// 	"github.com/sbinet/go-python"
// )

// // 初始化go-python
// func init() {
// 	err := python.Initialize()
// 	if err != nil {
// 		panic(err.Error())
// 	}
// }

// func main() {
// 	gostr := "foo"                             //定义goloang字符串
// 	pystr := python.PyString_FromString(gostr) //将golang字符串专程python字符串
// 	str := python.PyString_AsString(pystr)     //将python字符串，再转为golang字符串。
// 	fmt.Println("hello [", str, "]")

// 	pickle := python.PyImport_ImportModule("cPickle") //导入cPickle模块
// 	if pickle == nil {
// 		panic("could not import 'cPickle'")
// 	}

// 	dumps := pickle.GetAttrString("dumps") //获取dumps函数
// 	if dumps == nil {
// 		panic("could not retrieve 'cPickle.dumps'")
// 	}
// 	defer dumps.DecRef() //减少引用计数，释放资源。

// 	out := dumps.CallFunctionObjArgs("O", pystr) //针对python字符串进行dumps操作。
// 	if out == nil {
// 		panic("could not dump pystr")
// 	}
// 	defer out.DecRef()

// 	fmt.Printf("cPickle.dumps(%s) = %q\n", gostr,
// 		python.PyString_AsString(out),
// 	)

// 	loads := pickle.GetAttrString("loads") //获取loads函数
// 	if loads == nil {
// 		panic("could not retrieve 'cPickle.loads'")
// 	}
// 	defer loads.DecRef()
// 	out2 := loads.CallFunctionObjArgs("O", out) //将dumps结果重新loads
// 	if out2 == nil {
// 		panic("could not load back out")
// 	}
// 	defer out2.DecRef()

// 	fmt.Printf("cPickle.loads(%q) = %q\n",
// 		python.PyString_AsString(out),
// 		python.PyString_AsString(out2),
// 	)
// }