Access char[] variable from C language's structure to go - c

Question

Here I have test.h header file and in this header file I have declared one char a[10] variable. I have created one test.c file which includes test.h and assigns "Test" as a value. Now I have main.go file which will use that variable. Below are my code details.
test.h: this my header file
#ifndef _TEST_H
#define _TEST_H
typedef struct student student;
struct student {
char a[10];
};
student* show();
#endif
test.c: C source file which access test.h file and assign that variable a[10] with "Test"
#include "test.h"
#include <string.h>
student* show()
{
struct student *s= malloc(sizeof(struct student) * 1);
strcpy(s[0].a,"Test");
return s;
}
main.go
package main
// #cgo CFLAGS: -g -Wall
// #include <stdlib.h>
// #include "test.h"
import "C"
import (
"fmt"
"unsafe"
)
func main() {
s:= C.show();
defer C.free(unsafe.Pointer(s))
sSlice := (*[1]C.struct_student)(unsafe.Pointer(s));
fmt.Println(sSlice);
for _, ss := range sSlice {
fmt.Printf("A...%s", ss.a) //Here I want to access that variable
}
}
But Instead of showing Test its showing &[{[84 101 115 116 0 0 0 0 0 0]}].

Answer 1

The %s format specifier for Go works with Go strings and Go slices and arrays whose element type has the underlying type byte (such as []byte).
The ss.a field, as converted by cgo, has the Go type [10]C.char.
On many platforms, C.char is a signed character type, while Go's byte is always unsigned. So it may be the case that C.char has the underlying Go type int8 instead of byte (uint8), in which case fmt cannot print it using %s. In order to print it, you need to change the type.
One simple way to do that is to make a copy using C.GoString. C.GoString expects a *C.char, which in this case is the address of ss.a[0]:
for _, ss := range sSlice {
s := C.GoString(&ss.a[0])
fmt.Printf("A...%s\n", s)
}
(In C, ss.a and &ss.a[0] are equivalent, because C more-or-less does not distinguish between arrays and pointers. However, in Go arrays and pointers are completely distinct types.)
If the string may be large, you might want to avoid copying the entire slice into the Go heap.
You can express the change of type using unsafe.Pointer and convert it to a slice using Go 1.17's unsafe.Slice:
for _, ss := range sSlice {
s := unsafe.Slice((*byte)((unsafe.Pointer)(&ss.a[0])), len(ss.a))
fmt.Printf("A...%s\n", s)
}
Or, you could use the ConvertAt function from my unsafeslice package to express it a bit more simply:
for _, ss := range sSlice {
var s []byte
unsafeslice.ConvertAt(&s, ss.a[:])
fmt.Printf("A...%s\n", s)
}