C to Go Converter

#include <stdlib.h>
#include <string.h>

typedef struct {
    char* name;
    int age;
} Person;

Person* create_person(const char* name, int age) {
    Person* p = (Person*)malloc(sizeof(Person));
    if (p == NULL) return NULL;
    
    p->name = (char*)malloc(strlen(name) + 1);
    if (p->name == NULL) {
        free(p);
        return NULL;
    }
    
    strcpy(p->name, name);
    p->age = age;
    return p;
}

void free_person(Person* p) {
    if (p != NULL) {
        free(p->name);
        free(p);
    }
}

// Usage
Person* p = create_person("Alice", 30);
// ... use person ...
free_person(p);

package main

type Person struct {
    Name string
    Age  int
}

func NewPerson(name string, age int) *Person {
    return &Person{
        Name: name,
        Age:  age,
    }
}

// Usage
p := NewPerson("Alice", 30)
// ... use person ...
// No manual cleanup needed - garbage collector handles it

#include <pthread.h>
#include <stdio.h>

typedef struct {
    int* data;
    int size;
    int thread_id;
} ThreadData;

void* process_data(void* arg) {
    ThreadData* td = (ThreadData*)arg;
    for (int i = 0; i < td->size; i++) {
        td->data[i] *= 2;
    }
    printf("Thread %d done\n", td->thread_id);
    return NULL;
}

// Usage
int data[100];
pthread_t threads[4];
ThreadData thread_data[4];

for (int i = 0; i < 4; i++) {
    thread_data[i].data = &data[i * 25];
    thread_data[i].size = 25;
    thread_data[i].thread_id = i;
    pthread_create(&threads[i], NULL, process_data, &thread_data[i]);
}

for (int i = 0; i < 4; i++) {
    pthread_join(threads[i], NULL);
}

package main

import (
    "fmt"
    "sync"
)

func processData(data []int, threadID int, wg *sync.WaitGroup) {
    defer wg.Done()
    
    for i := range data {
        data[i] *= 2
    }
    fmt.Printf("Thread %d done
", threadID)
}

// Usage
data := make([]int, 100)
var wg sync.WaitGroup

chunkSize := 25
for i := 0; i < 4; i++ {
    wg.Add(1)
    start := i * chunkSize
    end := start + chunkSize
    go processData(data[start:end], i, &wg)
}

wg.Wait()