Início / user-13242312

Fayeure's questions

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

Considerando que o tipo Aé definido assim:

typedef struct a { const int a; } A;

Eu sei que este código é válido:

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

(veja https://stackoverflow.com/a/79012045/13242312 )

Mas ainda é válido com allocainstead of mallocse quisermos que o valor esteja na pilha em vez do heap?

Caso de uso: Quero um único caminho de retorno em minha função, então quero definir a variável de resultado no escopo da função

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

Sempre me perguntei se é uma boa prática sempre preferir constparâmetros quando possível? Por um lado, você diz ao compilador que essa variável não será mutada dentro do escopo da função para que ele possa fazer otimizações por baixo dos panos, mas, por outro lado, isso não afeta o chamador, já que os argumentos são passados ​​por cópia, então pode deixar o código inchado com consts em todos os lugares e, portanto, menos legível.

Alguém sabe que tipos de otimizações são feitas por baixo dos panos por compiladores em constparâmetros? Ele pode otimizar passando a variável como referência sem copiá-la, por exemplo? Há implicações de simultaneidade das quais devemos estar cientes? (por exemplo, ao mutar a variável em outro thread enquanto a função está em execução).

Os prós valem os contras?

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

Sou novato na rxjsbiblioteca, ainda estou aprendendo, e estou tentando implementar um servidor TCP em node.js usando Observable, e usando um padrão que vi na minha empresa que consiste em ter funções que recebem um Observablecomo entrada e retornam outra saída Observableque será enviada de volta ao cliente, então criei este código

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

Então basicamente neste exemplo eu quero esperar por uma login\nrequisição para o cliente, e então para cada requisição, quero ecoá-la de volta para o cliente, adicionando ACK: na frente dela, mas ao criar minha saída observável ele adiciona ACKmilhares de vezes em a mesma massagem, então parece que a saída está voltando para a função como entrada a cada vez, mas não sei por que, não estou alterando a entrada Observable, estou apenas retornando uma nova que será processada para ser enviado ao cliente, você pode me ajudar a apontar de onde vem o erro?

node.js