小编joh*_*ohn的帖子

所以我写了一个 dockerfile，当我运行图像时，路径是

/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin

我想在 PATH 中添加另一个条目，所以在我的 dockerfile 中我尝试了

ENV PATH="${PATH}:/some/new/path"

但是，当我尝试将 PATH 更改为包含我的个人路径（附加/some/new/path）时。如何安排它以便在/some/new/path不将 PATH 的其余部分更改为我的个人 PATH 的情况下附加它？

docker 镜像正在运行并带有--entrypoint /bin/bash参数--norc，如果可能的话我不想更改。

我使用的是 Ubuntu 14.04。

我在初始化指针数组时遇到了麻烦.我发现用gcc c ++(4.6.0)编译的是:

MyClass** a = new MyClass*[100];

并不总是初始化指针数组.(大多数时候它确实给了我一个让我困惑的空指针数组)

MyClass** a = new MyClass*[100]();

DOES将数组中的所有指针初始化为0(空指针).

我写的代码意味着可以在Windows/Linux/Mac/BSD平台上移植.这是gcc c ++编译器的一个特殊功能吗？还是标准的C++？它在标准中的位置是这样说的吗？

我无法理解这个程序的输出

int main()
{
    double x = 1.8939201459282359e-308;
    double y = 4.9406564584124654e-324;
    printf("%23.16e\n", 1.6*y);
    printf("%23.16e\n", 1.7*y);
    printf("%23.16e\n", 1.8*y);
    printf("%23.16e\n", 1.9*y);
    printf("%23.16e\n", 2.0*y);
    printf("%23.16e\n", x + 1.6*y);
    printf("%23.16e\n", x + 1.7*y);
    printf("%23.16e\n", x + 1.8*y);
    printf("%23.16e\n", x + 1.9*y);
    printf("%23.16e\n", x + 2.0*y);
}

输出是

9.8813129168249309e-324
9.8813129168249309e-324
9.8813129168249309e-324
9.8813129168249309e-324
9.8813129168249309e-324
1.8939201459282364e-308
1.8939201459282364e-308
1.8939201459282369e-308
1.8939201459282369e-308
1.8939201459282369e-308

我正在使用IEEE算法.该变量y保持最小的IEEE编号.前五张照片显示的数字是我预期的两倍.令我困惑的是,接下来的五个版画显示不同的数字.如果1.6*y是相同的2.0*y话怎么会x + 1.6*y有所不同x + 2.0*y？

将动态大小的数组传递给另一个函数的最"正确"的方法是什么？

bool *used = new bool[length]();

我想出了一些编译的方法,但我不太确定正确的方法是什么.

例如

这些会超过价值吗？

static void test(bool arr[])

static void test(bool *arr)

这个会通过引用传递吗？

static void test(bool *&arr)

谢谢

如何在C中初始化数组,如

void initArr(int size)
{
  ...
}

如果C语言的大小不是常量值,那么C语言不会给出初始化数组的选项,如果我通常初始化它(int*arr;)所以它给出了'arr'的错误没有被初始化.

类似地,当我有一个尺寸大于1的数组(例如矩阵)时,我怎么能这样做呢？

我正试图在球拍中定义一种新语言,让我们称之为wibble.Wibble将允许加载模块,因此必须将其表单转换为Racket需求表单.但是当我在语言扩展中使用时,我无法获得工作要求.我最终将我的问题追溯到以下奇怪的行为.

这是我的读者重新定义read和read-syntax

=== wibble/lang/reader.rkt ===
#lang racket/base

(provide (rename-out (wibble-read read) (wibble-read-syntax read-syntax)))

(define (wibble-read in)
  (wibble-read-syntax #f in))

(define (wibble-read-syntax src in)
  #`(module #,(module-name src) wibble/lang
      #,@(read-all src in)))

(define (module-name src)
  (if (path? src)
      (let-values (((base name dir?) (split-path src)))
        (string->symbol (path->string (path-replace-suffix name #""))))
      'anonymous-module))

(define (read-all src in)
  (let loop ((all '()))
    (let ((obj (read-syntax src in)))
      (if (eof-object? obj)
          (reverse all)
          (loop (cons obj all))))))

这是我简化的语言模块,这将介绍(require racket/base)每个wibble模块

=== wibble/lang.rkt === …

以下是有效的C++吗？这是将扁平结构实现可变长度尾部的另一种方法.在C中,这通常使用struct hack

struct Str
{
    Str(int c) : count(c) {}
    size_t count;
    Elem* data() { return (Elem*)(this + 1); }
};

Str* str = (Str*)new char[sizeof(Str) + sizeof(Elem) * count];
new (str) Str(count);
for (int i = 0; i < count; ++i)
    new (str->data() + i) Elem();
str->data()[0] = elem0;
str->data()[1] = elem1;
// etc...

我在回答以下相关问题时问这个问题

我有一个无向图.该图中的一个边缘是特殊的.我想找到包含第一条边的均匀循环的所有其他边.

我不需要列举所有周期,我认为这本身就是NP.我只需知道每个边缘是否满足上述条件.

蛮力搜索当然有效,但速度太慢,我正在努力想出更好的东西.任何帮助赞赏.

昨天我问一个问题,为什么我是在一个浮点运算精度损失.我收到一个关于如何在x87寄存器中保存中间结果的答案.这很有帮助,但有些细节仍在逃避.这是我在上一个问题中提出的程序的变体,我在调试模式下使用VC++ 2010 Express.

int main()
{
    double x = 1.8939201459282359e-308; /* subnormal number */
    double tiny = 4.9406564584124654e-324; /* smallest IEEE double */
    double scale = 1.6;
    double temp = scale*tiny;
    printf("%23.16e\n", x + temp);
    printf("%23.16e\n", x + scale*tiny);
}

这输出

1.8939201459282369e-308
1.8939201459282364e-308

根据IEEE标准,第一个值是正确的.赋予scale变量值2.0可为两种计算提供正确的值.据我所知,temp在第一次计算中是一个次正规值,因此失去了精度.我也理解,值scale*tiny保存在x87寄存器中,该寄存器具有更大的指数范围,因此该值具有更高的精度temp.我不明白的是,在添加值时,x我们从较低的精度值中得到正确的答案.当然,如果较低的精度值可以给出正确的答案,那么更高的精度值也应该给出正确的答案吗？这与"双舍入"有关吗？

在此先感谢,这对我来说是一个全新的主题,所以我有点挣扎.

我正在编写一些代码，将 lambda 函数传递给一组递归函数。其中一些 lambda 函数嵌套在其他 lambda 函数内。我认为我正在编写有效的代码，但出现错误fatal error C1060: compiler is out of heap space。

这是代码的精简版本

struct Null
{
    template <typename SK>
    static void match(SK sk)
    {
    }
};

template <typename T>
struct Repetition
{
    template <typename SK>
    static void match(SK sk)
    {  // <--------------------------------- error message points to this line
        T::match([]() { match([]() {}); });
    }
};

int main()
{
    using Test = Repetition<Null>;
    Test::match([](){});
}

现在这个最小版本没有多大意义，但它有相同的编译器错误。我已经指出了上面错误的行。

我的问题是，这是编译器错误/限制还是我的代码在某种程度上无效？

编译器是 Visual Studio 2022 编译 C++20。

谢谢