if(auto r = find(); r) {
  r->name();
}

S>>Так ведь это вопрос, по которому консенсуса не смогли найти

S>>void fun1(std::unique_ptr<Class1> smart_ptr){}
S>>

S>Вроде очевидно, что тип с префикосм "unique" не должен так использоваться

void ensure_valid(const Transaction & trx);
void log_acceptance(const Transaction & trx);
void push_to_processing(std::unique_ptr<Transaction> trx);

...
while(!stop) {
  std::unique_ptr<Transaction> trx = acquire_new_trx();
  ensure_valid(*trx); // Не отдаем владение.
  log_acceptance(*trx); // Не отдаем владение.
  push_to_processing(std::move(trx)); // Отдали владение и забыли про объект.
}

auto data = std::unique_ptr<QSurfaceDataArray>(new QSurfaceDataArray);
...
// series takes ownership
m_powerSeries->dataProxy()->resetArray(data.release());

#include <iostream>
#include <string>

// Функция для считывания строки с клавиатуры
std::string readStringFromInput() {
    std::string inputString;
    std::cout << "Введите строку: ";
    std::getline(std::cin, inputString);
    return inputString;
}

int main() {
    // Вызываем функцию для считывания строки
    std::string str = readStringFromInput();

    // Выводим считанную строку на экран
    std::cout << "Вы ввели строку: " << str << std::endl;

    return 0;
}

use std::io;

// Функция для считывания строки с клавиатуры
fn read_string_from_input() -> String {
    let mut input_string = String::new();
    println!("Введите строку:");
    io::stdin().read_line(&mut input_string).expect("Ошибка при считывании строки");
    input_string
}

fn main() {
    // Вызываем функцию для считывания строки
    let str = read_string_from_input();

    // Выводим считанную строку на экран
    println!("Вы ввели строку: {}", str);
}

const std = @import("std");

pub fn readStringFromInput(allocator: *std.mem.Allocator) ![]const u8 {
    var stdin = std.io.getStdIn();
    const bufferSize: usize = 1024;
    var buffer: [bufferSize]u8 = undefined;

    var builder = std.heap.Writer.init(allocator);
    while (try stdin.read(buffer[0..]) |chunk|) |chunk| {
        try builder.append(chunk);
    }

    return builder.toOwnedSlice();
}

pub fn main() void {
    const allocator = std.heap.page_allocator;
    defer allocator.deinit();

    const inputString = try readStringFromInput(allocator);

    const output = std.io.getStdOut();
    try output.print("Вы ввели строку: {}\\n", .{inputString});
}

S>Zig это —

fn nextLine(reader: anytype, buffer: []u8) !?[]const u8 {
    var line = (try reader.readUntilDelimiterOrEof(
        buffer,
        '\n',
    )) orelse return null;
    // trim annoying windows-only carriage return character
    if (@import("builtin").os.tag == .windows) {
        return std.mem.trimRight(u8, line, "\r");
    } else {
        return line;
    }
}

test "read until next line" {
    const stdout = std.io.getStdOut();
    const stdin = std.io.getStdIn();

    try stdout.writeAll(
        \\ Enter your name:
    );

    var buffer: [100]u8 = undefined;
    const input = (try nextLine(stdin.reader(), &buffer)).?;
    try stdout.writer().print(
        "Your name is: \"{s}\"\n",
        .{input},
    );
}