主页 / user-13242312

Fayeure's questions

Martin Hope
Fayeure
Asked: 2025-04-29 15:42:10 +0800 CST
  • 6

考虑到类型A定义如下：

typedef struct a { const int a; } A;

我知道此代码是有效的：

A * foo = malloc(sizeof *foo); // Allocates uninitialized memory with no effective type
memcpy(foo, &(typeof(*foo)){ .a = 42, }, sizeof *foo); // Effectively initialize the value once

（参见https://stackoverflow.com/a/79012045/13242312）

但是，如果我们希望值位于堆栈而不是堆中，alloca那么使用 而不是是否仍然有效？malloc

用例：我希望函数中有一个返回路径，因此我想在函数范围内定义结果变量

A A_new(void) {
  A * a = alloca(sizeof *a);

  if (/* something */) {
    memcpy(a, &(typeof(*a)){.a = 1}, sizeof *a);
  } else {
    memcpy(a, &(typeof(*a)){.a = 2}, sizeof *a);
  }

  return *a;
}
c
Martin Hope
Fayeure
Asked: 2024-11-08 18:18:40 +0800 CST
  • 8

我一直想知道，在可以的情况下始终优先使用参数是否是一种好的做法const？一方面，你告诉编译器这个变量不会在函数范围内发生变异，因此它可以在后台进行优化，但另一方面，由于参数是通过复制传递的，因此它不会影响调用者，因此它会使代码const到处都是 s 而变得臃肿，从而降低可读性。

有人知道编译器在参数上做了哪些优化吗const？例如，它可以通过传递变量作为引用而不复制它来进行优化吗？是否存在我们应该注意的并发影响？（例如，在函数运行时在另一个线程中改变变量时）。

其优点是否值得其缺点？

c
Martin Hope
Fayeure
Asked: 2024-04-07 21:50:37 +0800 CST
  • 5

我是这个库的新手rxjs，仍在学习它，我正在尝试使用 node.js 实现 TCP 服务器Observable，并使用我在公司看到的模式，该模式包含具有作为Observable输入和返回的函数另一个输出Observable将发送回客户端，所以我想出了这个代码

import net from "net";
import * as rx from "rxjs";

type MaybePromise<T> = T | PromiseLike<T>;
type ConnectionHandler = (address: net.AddressInfo, input$: rx.Observable<Buffer>) => MaybePromise<rx.Observable<Buffer>>;

const createServer = (port: number, handler: ConnectionHandler, opts?: net.ServerOpts) => {
  const server = net.createServer(opts);

  new rx.Observable<net.Socket>(subscriber => {
    server
      .on("connection", socket => subscriber.next(socket))
      .on("error", err => subscriber.error(err));
  }).subscribe(async socket =>
    (await handler(
      socket.address() as net.SocketAddress,
      new rx.Observable<Buffer>(subscriber => {
        socket
          .on("end", () => socket.destroySoon())
          .on("error", err => subscriber.error(err))
          .on("data", request => subscriber.next(request))
          .on("close", () => subscriber.complete());
      }),
    )).subscribe({
      next: response => {
        console.log(response.toString());
        socket.emit("data", response);
      },
      error: () => socket.destroySoon(),
    })
  );

  server.listen(port);
};

createServer(3000, async (address, input$) => {
  console.log(`New client: ${address.address}`);

  const login = await rx.firstValueFrom(input$);

  if (login.toString() != "login\n")
    return rx.throwError(() => new Error("login failure"));

  return input$.pipe(
    rx.map(data => {
      return Buffer.from(`ACK: ${data.toString()}`, "utf-8");
    })
  );
});

所以基本上在这个例子中，我想等待login\n客户端的请求，然后对于每个请求，我想将其回显给客户端，并ACK: 在其前面添加，但是在创建我的输出可观察时，它会添加ACK数千次相同的按摩，所以看起来输出每次都会返回到函数作为输入，但我不知道为什么，我没有更改输入Observable，我只是返回一个将被处理的新输入发给客户，你能帮我指出错误出在哪里吗？

node.js