Ownership & Lifetimes

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

/* OWNERSHIP CONTRACT (by comment - the only tool C gives you):
 * Returns a heap-allocated, NUL-terminated greeting for `name`.
 * OWNERSHIP TRANSFERS to the caller, who MUST free() it.
 * Returns NULL on allocation failure (caller owns nothing). */
char *make_greeting(const char *name) {
    size_t n = strlen(name) + 8;   /* "Hello, " == 7 chars, +1 for NUL */
    char *out = malloc(n);         /* allocate -> we own it... */
    if (out == NULL) return NULL;  /* ...unless this fails */
    snprintf(out, n, "Hello, %s", name);
    return out;                    /* ownership handed to caller */
}

int main(void) {
    char *g = make_greeting("Dennis");   /* caller now owns `g` */
    if (g == NULL) return 1;
    /* ... use g ... */
    free(g);                              /* caller MUST free it */
    g = NULL;                             /* avoid dangling reuse */
    return 0;
}

#include <memory>
#include <string>
#include <iostream>

// Ownership is encoded IN THE TYPE: unique_ptr means "I own this,
// exactly one owner at a time." Returning it MOVES ownership out.
std::unique_ptr<std::string> make_greeting(const std::string &name) {
    return std::make_unique<std::string>("Hello, " + name);
    // single heap allocation; destructor knows how to free it
}

int main() {
    auto g = make_greeting("Bjarne");   // g now owns the string
    std::cout << *g << '\n';

    auto h = std::move(g);              // ownership MOVES: g is now null
    // using *g here would be a bug; the type made the move explicit
    std::cout << *h << '\n';
    return 0;                            // ~unique_ptr frees automatically (RAII)
}

// HolyC (TempleOS): MAlloc/Free are the heap primitives.
// Ownership is by convention + comment, like C. No destructors.

U8 *MakeGreeting(U8 *name)
{// Returns a heap string the CALLER must Free().
  I64 len = StrLen(name) + 8; // "Hello, " + NUL
  U8 *out = MAlloc(len);      // we own this block...
  StrPrint(out, "Hello, %s", name);
  return out;                 // ...ownership handed to caller
}

U8 *g = MakeGreeting("Terry"); // top-level code runs; g is owned here
"%s\n", g;                     // HolyC shorthand for Print
Free(g);                       // caller MUST Free it exactly once

const std = @import("std");

// The Allocator is passed IN explicitly: no hidden allocations.
// Returns owned memory; caller frees with the SAME allocator.
// The `!` means it can fail (error.OutOfMemory).
fn makeGreeting(allocator: std.mem.Allocator, name: []const u8) ![]u8 {
    return std.fmt.allocPrint(allocator, "Hello, {s}", .{name});
    // allocPrint allocates -> ownership returned to the caller
}

pub fn main() !void {
    // GeneralPurposeAllocator detects leaks and double-frees in debug.
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer _ = gpa.deinit();          // reports leaks at program end
    const allocator = gpa.allocator();

    const g = try makeGreeting(allocator, "Andrew"); // caller owns g
    defer allocator.free(g);         // freed at scope exit, deterministically

    std.debug.print("{s}\n", .{g});
}

use fmt;
use strings;

// Convention: a fn that returns alloc'd memory transfers ownership.
// Caller must free! it. Hare has no GC and no destructors.
fn make_greeting(name: const str) str = {
	return strings::concat("Hello, ", name); // allocates -> caller owns
};

export fn main() void = {
	const g = make_greeting("Drew"); // g is owned here
	defer free(g);                   // freed at scope exit, exactly once

	fmt::println(g)!;
};

package main

import "core:fmt"
import "core:strings"

// Odin threads an implicit `context.allocator` through calls.
// Convention: returning allocated memory transfers ownership to caller.
make_greeting :: proc(name: string) -> string {
	// concatenate uses context.allocator by default -> caller owns result
	return strings.concatenate({"Hello, ", name})
}

main :: proc() {
	g := make_greeting("Ginger")   // caller owns g
	defer delete(g)                // free with the same allocator, once

	fmt.println(g)
}

\ Forth has no malloc/free in the core: memory is hand-managed.
\ The IDIOM closest to "return owned memory" is to reserve a region
\ from the dictionary with ALLOT and hand back its address.

CREATE GREETING  64 ALLOT      \ reserve a 64-byte buffer in the dictionary

: S"->BUF ( addr len dst -- )  \ copy a string into dst
  SWAP CMOVE ;

: MAKE-GREETING ( -- addr )    \ "returns" the buffer address
  S" Hello, Forth" GREETING S"->BUF
  GREETING ;                   \ caller now holds the address (not malloc'd)

MAKE-GREETING  12 TYPE  CR     \ use it: prints "Hello, Forth"
\ No FREE needed: dictionary memory lives until FORGET/MARKER rolls it back.