问题列表 - 第317956页

我正在使用 Stanley 的《C++ Primer》一书学习 C++。特别是，关于“指针转换”的部分说：

指向任何非常量类型的指针都可以转换为void*

读完本文后，我编写了以下程序，该程序使用 msvc 进行编译，没有任何诊断，但被 gcc 和 clang 拒绝。演示

int func()
{
    return 4;
}
int main()
{
    void* ptr = &func; //works with msvc but rejected by clang and gcc
}

正如你所看到的，上面的程序适用于 msvc，但 gcc 说error: invalid conversion from 'int (*)()' to 'void*'。

我想知道哪个编译器在这里是正确的。请注意，我已将/permissive-flag 与 msvc 一起使用以使其符合标准。

如何获取对存储在RefCell. 获得对结构体不同字段的可变引用有什么危害？

use std::cell::{RefCell, RefMut};

#[derive(Default)]
struct A {
    a: i32,
    b: u32,
}

fn main() {
    let mut a_ref_cell: RefCell<A> = Default::default();
    let mut a_obj = a_ref_cell.borrow_mut();
    let a_ref = &mut a_obj.a;
    let b_ref = &mut a_obj.b;
    
    *a_ref = 2;
    *b_ref = 78;
    
    println!("{}, {}", *a_ref, *b_ref);
    println!("Hello, world!");
}

错误

error[E0499]: cannot borrow `a_obj` as mutable more than once at a time
  --> src/lib.rs:62:22
   |
61 |     let a_ref = &mut a_obj.a;
   |                      ----- first mutable …

在 RxJS 中，我怎样才能实现这一点：我有两个主题。我想要一个以这种方式组合它们的可观察量：当两者都发出值时，发出它们的最新值。然后，两者都需要至少再次发射一次，然后发射它们最新的发射值，等等。

两个科目：

1 ---------- 2 ----- 3 -- 4 ---------------- 5 ------ 6 -----------------

------- a ------------------ b ------ c --------------------- d --------

可观察的目标：

------- 1a ----------------- 2b ----- 3c ------------------- 4d -------

周日似乎是从版本 4.2.3 更新到 4.3.2（在 Win 10 上）的好日子R，以开始新的一周。

我正在使用该zoo包将一些时间序列写入基本文本文件以保存数据。这工作了很多年，但在上述升级之后，我遇到了输出的变化，突然午夜时间被遗漏了：

测试代码（使用zoo版本1.8.12）：

library(zoo)
write.zoo(
  zoo(
    c(46, 47),
    c(as.POSIXct("2023-11-26 00:00:00"), as.POSIXct("2023-11-26 01:00:00"))
  )
)

对于 4.3.0 之前的 R，结果如下所示：

"2023-11-26 00:00:00" 46
"2023-11-26 01:00:00" 47

但从 4.3.0 开始，它更改为：

"2023-11-26" 46
"2023-11-26 01:00:00" 47

正如文档所说zoo，这write.zoo()是一个方便的函数，write.table()我尝试用它来代替，再次获得正确的结果（带有午夜时间戳）：

write.table(
  zoo(
    c(46, 47),
    c(as.POSIXct("2023-11-26 00:00:00"), as.POSIXct("2023-11-26 01:00:00"))
  )
)

输出

"2023-11-26 00:00:00" 46
"2023-11-26 01:00:00" 47

在任何提到的R.

所以看起来这个write.zoo函数已经被 R >= 4.3.0 破坏了，但故事还在继续......

zoo 正如人们在源代码 …

我在名为“keys.json”的文件中设置了一些环境变量，并使用--dart-define-from-file来加载它们。

flutter run --dart-define-from-file=keys.json

通过命令行它可以正常工作，但是使用 Xcode 时又如何呢？

如何设置--dart-define-from-file变量以便我可以在 Xcode 中运行和构建项目？

我正在 Visual Studio Community 中使用 C++20 编写跨平台代码，但我陷入了以下代码的输出：

#define WINDOWS (defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__NT__))
#define UNIX (defined(__unix__) || defined(__unix))

constexpr bool is_unix1()
{
#ifdef UNIX
    return true;
#else
    return false;
#endif
}

constexpr bool is_unix2()
{
#ifdef defined(UNIX)
    return true;
#else
    return false;
#endif
}


int main()
{
    cout << std::boolalpha << is_unix1() << " " << is_unix2() << endl;
}

当我在 Windows 中从 VS Community 内部运行此代码时，我得到以下输出：

true false

有人可以解释为什么is_unix1()评估为falsewhileis_unix2()评估为吗true？ …

我有一个很大的数据集，基本上是这样加载的：

for(int i=0;i<count; i++){
   auto ptr = std::make_shared<Object>(Object());
   //do stuff with ptr
}

由于内存分配是零碎的，这对性能来说并不是很好。我想做的是这样的：

std::shared_ptr<Object[]> allObjects; //this is stored elsewhere until the program ends

allObjects.reset(new Object[count]);
for(int i=0;i<count; i++){
   auto ptr = std::weak_ptr<Object>(&allObjects[i]);
   //do stuff with ptr
}

不幸的是这不能编译。我可以这样尝试：

auto ptr = std::shared_ptr<Object>(&allObjects[i]);

这在程序运行时效果很好，但是当然，当 ptr 的所有副本都被销毁时，就要付出惨重的代价。所以我希望 ptr 成为 std::weak_ptr。主数组 std::shared_ptr 将被存储，直到所有weak_ptr被销毁。那么我可以为数组类型 std::shared_ptr 的索引成员创建一个 std::weak_ptr 吗？我只是缺少一些语法吗？我需要不同的容器类型吗？或者我是否遗漏了该方法的根本错误？

我很好奇为什么 Haskell 或任何函数式语言中似乎缺乏有限元方法 (FEM) 实现。鉴于 Haskell 的纯函数性质，我期望找到大量数值方法的实现。

我在 GitHub 和 Google Scholar 上快速搜索并没有找到很多相关参考文献。我遇到了一个关于 Haskell 在处理大型矩阵中的应用的 Quora 问题，但没有一个答案提到稀疏矩阵或 FEM。Haskell 社区内是否有关于缺乏 FEM 实施的具体讨论或原因？我希望对此事有见解或参考。

问题！

我正在开发基于 SwiftUI 的 iPhone / iPad 应用程序，当我将 iPad 连接（通过 USB 线）到 Mac Mini（运行 Xcode 的开发机器）时，运行应用程序时有时会出现如下所示的消息来自 Xcode（在调试模式下）：

当 Xcode 说“从 <连接的设备> 复制共享缓存符号”时，它在做什么？

为什么它要从 ipad 复制这些？看起来它会从 Xcode 或我连接的 Mac Mini（运行 Xcode 的开发机器）复制这些。

另外，我猜它正在通过 USB 电缆发送这些符号，对吧？

这些是调试符号吗？

此外，这还取决于特质的细节。

我有两个最小的板条箱。第一个是一个图书馆箱子foo，里面有

#![allow(incomplete_features)]
#![feature(generic_const_exprs)]

pub trait KnownSize: Sized {
    const N: usize = core::mem::size_of::<Self>();
}
impl<T: Sized> KnownSize for T {}

pub trait SizeIs<const N: usize> {}
impl<T: KnownSize> SizeIs<{ T::N }> for T {}

struct X(u32);

// Uncommenting either of these lines breaks due to conflict with blanket impls above
// impl KnownSize for X {}
// impl SizeIs<4> for X {}

在板条箱里bar，我有

use foo::*;

struct X(u32);

// Uncommenting this line breaks due to conflict …