#include <iostream>

struct Class1 { const int i1 = 42; };

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

int main()
{
    auto smart_ptr1 = std::make_unique<Class1>();
    fun1(std::move(smart_ptr1));

    std::cout << smart_ptr1->i1 << std::endl;
}

S>#include <iostream>

S>struct Class1 { const int i1 = 42; };

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

S>int main()
S>{
S>    auto smart_ptr1 = std::make_unique<Class1>();
S>    fun1(std::move(smart_ptr1));

S>    std::cout << smart_ptr1->i1 << std::endl;
S>}
S>

#include <iostream>

struct Class1 { const int i1 = 42; };

void fun1(Class1& class1){}

int main()
{
    Class1 class1;
    fun1(class1);

    std::cout << class1.i1 << std::endl;
}

M>А теперь напиши связный список на rust

// Определение структуры узла списка
struct Node<T> {
    value: T,
    next: Option<Box<Node<T>>>,
}

// Определение структуры списка
pub struct LinkedList<T> {
    head: Option<Box<Node<T>>>,
}

impl<T> LinkedList<T> {
    // Создать новый пустой список
    pub fn new() -> Self {
        LinkedList { head: None }
    }

    // Добавить элемент в начало списка
    pub fn push(&mut self, value: T) {
        let new_node = Box::new(Node {
            value,
            next: self.head.take(),
        });
        self.head = Some(new_node);
    }

    // Удалить и вернуть первый элемент списка, если он есть
    pub fn pop(&mut self) -> Option<T> {
        self.head.take().map(|node| {
            self.head = node.next;
            node.value
        })
    }

    // Проверить, пуст ли список
    pub fn is_empty(&self) -> bool {
        self.head.is_none()
    }
}

fn main() {
    let mut list = LinkedList::new();

    list.push(1);
    list.push(2);
    list.push(3);

    while !list.is_empty() {
        println!("{}", list.pop().unwrap());
    }
}

M>А теперь напиши связный список на rust

struct Node {
  data: T,
  next: Option<Box<T>>,
}

struct Node<T> {
    data: T,
    prev: Option<Weak<Node<T>>>,
    next: Option<Rc<Node<T>>>,
}

template<typename T>
struct Node {
    T data;
    std::shared_ptr<Node<T>> next;
    std::weak_ptr<Node<T>> prev;
};

#include <iostream>
#include <memory>

struct Class1 { const int i1 = 42; };

struct Class2Wrapper
{
    Class2Wrapper(std::unique_ptr<Class1> &inner)
    {
        _inner = std::move(inner);
    }

    void print() { std::cout << _inner->i1 << std::endl; }
    
private:
    std::unique_ptr<Class1> _inner;
};

void fun1(std::unique_ptr<Class1>& smart_ptr)
{
    // Удобно обернули, чтобы удобно использовать
    Class2Wrapper wrapper(smart_ptr);

    wrapper.print();
}

int main() {
    auto smart_ptr = std::make_unique<Class1>();
    fun1(smart_ptr); // передали по сслыке, все ОК

    std::cout << smart_ptr->i1 << std::endl; // тролололошеньки!!!

    return 0;
}

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},
    );
}