小编Rem*_*eau的帖子

我可以初始化一个恒定的动态数组吗？

如果:

type
  tNamePair = array[1..2] of String;
  tPairList = array of tNamePair;

如何创建初始化常量？我无法得到以下代码编译:

const
  PairList: tPairList = ( ('One', '1'), 
                          ('Two', '2'),
                          ('Three', '3'));

如果那是不可能的,可以用固定数组初始化一个固定的固定数组:

 type
    tPairList: array[1..3] of tNamePair;

如果这不可能,可以使用记录初始化常量动态数组:

tNamePair = record 
              English: String;
              Number: String;
            end;           
tPairList = array of tNamePair;

如果不可能,可以使用记录初始化常量固定数组:

tNamePair = record 
              English: String;
              Number: String;
            end;           
tPairList = array[1..3] of tNamePair;

如果这是不可能的,除了代码中的硬连线分配之外的任何建议,坦率地说,这比我撰写这个问题花费的时间少!

我正在 Delphi 中编写一个下载管理器，其中包含一些自定义功能，例如可恢复下载和通过代理下载。

我正在研究不同的组件解决方案：Indy 和 NetHTTP，两者看起来非常接近。

• TNetHTTPClient好像是 的接口winhttp.dll。

• TIdHTTP似乎是wininet.dll（但我不确定）的接口。

• TIdHTTP 似乎是一个非常古老的组件（可能非常稳定/经过测试）并且有大量在线文档。

• TNetHTTPClient 似乎是一个非常新的组件，并且没有很好的在线文档。

我有点犹豫……该选择哪一个？

关键是：这两个组件之间的主要区别是什么？

我的问题有点有争议（主要基于意见），但我还没有找到这两个组件之间的任何实际比较。

我正在尝试自学一些 C++17。

为什么编译器会为以下代码片段抛出错误？

#include <iostream> 
#include <vector>
#include <iterator>

int main() 
{
    std::vector<int> v = { 3, 1, 4 };
    std::cout << std::size(v) << '\n'; 

    int a[] = { -5, 10, 15 };
    std::cout << std::size(a) << '\n';
}

编译器抛出以下错误

manish@Manish-Tummala:~/c_files$ g++ 6.cpp -o - 6.out
6.cpp: In function ‘int main()’:
6.cpp:8:23: error: ‘size’ is not a member of ‘std’
     std::cout << std::size(v) << '\n';
                       ^~~~
6.cpp:8:23: note: suggested alternative: ‘size_t’
     std::cout << std::size(v) << '\n';
                       ^~~~
                       size_t
6.cpp:11:23: error: …

#include <iostream>
using namespace std;

int main() { 
   int  arr[5] = {5, 8, 1, 3, 6};
   int len = *(&arr + 1) - arr;
   cout << "The length of the array is: " << len;
   return 0;
} 

对于上面的代码，我不太明白这两段代码是做什么的：

*(&arr + 1) 

和

*(&arr)
&arr

有人可以解释一下吗？因为当我运行以下两个代码时，我得到以下相同的输出：

&arr （我认为这指向arr的第一个元素的地址）

*(&arr)那么我不太明白这是做什么的，符号*对&arr（即这里的地址）有什么作用？，因为当我运行它们时，两个输出是相同的

最后，当一个整数说 1 被这里的代码添加到地址时，到底发生了什么： &arr + 1

下面的代码不能在 Visual Studio 中编译，给出

错误 C2672 'operator __surrogate_func'：未找到匹配的重载函数 sortms C:\Users\David\source\repos\sortms\sortms.cpp 103

当我使用 C 风格数组时，该函数按照编写的方式工作。如果我使用指定的注释代码，该函数也可以工作input.begin(), input.end(), output.begin()。

我使用的是 Visual Studio Community 2019 v16.8.6，使用该/std:c++latest选项进行编译。我认为标准容器是基于范围的？

std::range::copy()有人可以帮助我更好地理解vsstd::copy()在处理向量或其他标准容器时的优势吗？

#include <iostream>
#include <ranges>
#include <algorithm>
#include <array>
#include <utility>
#include <vector>
#include <functional>
#include <string>
#include <concepts>

void ranges_copy_demo()
{
    std::cout << "\nstd::ranges::copy()\n";

/*
    int const input[] = { 1, 2, 3, 5, 8, 13, 21, 34, 45, 79 };
    int output[10] = { 0 };
*/
    std::vector<int> input …

string::c_str()调用时实际上做了什么？

1. string::c_str()将分配内存，复制字符串对象的内部数据并将空终止字符附加到新分配的内存中？

或者

2. 由于必须是 O(1)，因此不再允许string::c_str()分配内存并复制过来。string实际上，始终存在空终止符是唯一合理的实现。

在这个问题的答案的评论中有人说C++11 要求为尾随std::string分配额外的char'\0'. 所以看来第二种选择是可能的。

另一个人说，std::string操作——例如迭代、串联和元素变异——不需要零终止符。除非您将 传递string给需要以零结尾的字符串的函数，否则可以省略它。

更多来自专家的声音：

为什么实现者通常让 .data() 和 .c_str() 做同样的事情？

因为这样做效率更高。使 .data() 返回非 null 终止的内容的唯一方法是让 .c_str() 或 .data() 复制其内部缓冲区，或者仅使用 2 个缓冲区。拥有一个以 null 结尾的缓冲区始终意味着您在实现 std::string 时始终可以仅使用一个内部缓冲区。

string::c_str()所以我现在真的很困惑，调用时实际上做了什么？

更新：

如果c_str()实现为简单地返回指针，则它已经被分配和管理。

A。由于c_str()必须以 null 终止，因此内部缓冲区需要始终以 null 终止，即使对于空的 std::string，例如： ;的内部存储器中std::string demo_str应该有一个。我对吗？\0demo_str

B.std::string::substr()调用时会发生什么自动将 a …

基于此链接条件编译(Delphi) CPUARM条件,如果模拟器应为false,设备为true,问题是它对我不起作用.我在用Delphi XE6, iOS Simulator 7.1

这是我的代码

    {$IFDEF CPUARM}
s := 'iOS device';
    {$ELSE}
s := 'iOS Simulator';
    {$ENDIF}

ps iOS模拟器正在VMWare虚拟机中运行.

int我喜欢使用枚举类，但有时我将它们用作标志，如果我想使用按位运算符，我必须不断地进行转换。有没有办法在不铸造的情况下做到这一点？我认为您无法为它们定义运算符？

如果我有采用枚举类的函数，我必须这样做吗？

enum class Flags { FLAG1, FLAG2, FLAG3};

void setFlags(Flags flags){}

int main()
{
      setFlags((Flags)((int)Flags::FLAG1 | (int)Flags::FLAG2 | (int)Flags::FLAG3));
}

我很难理解如何阻止代码std::conditional_t在错误分支中被评估。

#include <type_traits>\n\nusing namespace std;\n\nnamespace {\n    template <typename T>\n    using BaseDifferenceType = decltype (T{} - T{});\n}\n\nint main ()\n{\n    using T = int;\n    static_assert(! is_enum_v<T>);\n    BaseDifferenceType<T> xxx {};\n    \n    // PROBLEM IS HERE - though is_enum is false, we still evaluate underlying_type<T> and complain it fails\n    using aaa = conditional_t<is_enum_v<T>, underlying_type_t<T>, BaseDifferenceType<T>>;\n    \n    return 0;\n}\n

您可以在https://www.onlinegdb.com/uxlpSWVXr在线尝试此操作。

编译（使用 C++17）给出错误：

#include <type_traits>\n\nusing namespace std;\n\nnamespace {\n    template <typename T>\n    using BaseDifferenceType = decltype (T{} - T{});\n}\n\nint …

以下代码（取自维基百科）定义了变量模板 pi<>：

template<typename T=double>
constexpr T pi = T(3.14159265358979323846264338328);
template<>
constexpr const char* pi<const char*> = "?";

使用 clang 编译器（Apple clang 版本 12.0.0）（使用 C++14），这会触发警告（使用-Weverything）：

之前没有非静态变量 'pi<const char *>' 的 extern 声明

如果变量不打算在此翻译单元之外使用，则声明“静态”

此外，由于这是在标头中定义的，因此创建了多个 'myNameSpace::pi<char const*>' 实例，导致链接器错误。

因此，按照建议，我添加了static关键字，从而使警告静音：

template<>
static constexpr const char* pi<const char*> = "?";

但是现在gcc（9.3.0）不爽，报错指向static关键字：

错误：显式模板特化不能有存储类

避免警告和错误的正确方法是什么？