小编xsk*_*xzr的帖子

标准C++ [3.9.1-1]说明了这一点

对于无符号字符类型,值表示的所有可能位模式表示数字.

标准[18.3.2.4-(注释197)]也表示无符号字符的最大值等于UCHAR_MAXC,C在C标准[5.2.4.2.1]中定义为255.那么这是否意味着C++中unsigned char类型的大小恰好是8位？

在分析算法的时间复杂度时，我们通常认为数组的随机访问时间是一个常数（数组的大小n不是一个常数），但为什么呢？

考虑图灵机模型，其中数组存储在磁带中，要访问数组的特定元素，其磁带头必须移动到该位置，这需要 O(n) 时间。或者是否有其他方法来存储图灵机的数组，以便随机访问只需要恒定的时间？

这可以在 C 中得到保证，因为 WG14/N1570 中有以下句子：

6.2.5/20 ... 数组类型描述了具有特定成员对象类型的连续分配的非空对象集，称为元素类型。

但是在WG21/N4527中，即在C++中，对应的句子变成了

8.3.4/1 ...数组类型的对象包含连续分配的 N 个 T 类型子对象的非空集合。

而“描述”一词改为“包含”，这不能保证数组的地址等于它的第一个元素的地址。这种改变是有意的还是无意的？如果是故意的，数组的地址是否等于它在 C++ 中的第一个元素的地址？如果是这样，C++ 标准中的哪一段可以保证这一点？

无法弄清楚为什么我使用以下代码获得编译器错误:

#include <tchar.h>

typedef TCHAR Char;

typedef std::basic_string<Char> String;

template<typename C, typename T>
std::basic_string<C> InternalToString(T val);

template<typename T>
inline std::string InternalToString<char, T>(T val)
{
    return std::to_string(val);
}

template<typename T>
inline std::wstring InternalToString<wchar_t, T>(T val)
{
    return std::to_wstring(val);
}

template<typename T>
inline String ToString(T val)
{
    return InternalToString<Char, T>(val);
}

如果我用MSVC 2017编译代码我得到"错误C2768:'InternalToString':非法使用显式模板参数"

我写了下面这段代码

#include <iostream>
const int N = 5;
class X
{
  public:
  int array[N];
  void foo()
  {
     std::cout << "array size:"<<sizeof(array)/N << std::endl;   
  }
  enum
 {
   N = 3    
  };
};

int main()
{
  X x;
  x.foo();
} 

上述代码不能与GCC一起编译:

<source>:13:8: error: declaration of 'N' [-fpermissive]
    N = 3
        ^
<source>:2:11: error: changes meaning of 'N' from 'const int N' [-fpermissive]
 const int N = 5;
           ^

从我在编译时的观点来看,数组被定义为一个包含五个整数的数组,N被定义为5.如何编译器解析变量的名称声明？

我不明白为什么这不起作用：

auto a = (int[]){1, 2, 3, 4, 5};

> error: taking address of temporary array

我知道数组左值在转换为右值时会衰减为指针，但这里数组已经是右值（实际上是纯右值），因此不需要衰减。我本来期望a被推导并初始化为int[5]. 为什么它试图获取临时地址？

我意识到以下是可怕的风格,但为了争论,假设我有以下代码:

struct parent
{
   virtual ~parent() {}
};

struct child : public parent
{
   child() {}
   virtual ~child() {}
};

struct anotherClass
{
   static parent& anyName;
};

child anyName; // create an instance of 'child'
parent& anotherClass::anyName = anyName; // create a parent-class ref to the child object

当我初始化anotherClass::anyName上面的参考时,我用anyName它anyName初始化它？子类对象,还是自己？(anyName最后一行中的最后一个实体引用哪个实体？它是不明确的吗？)在C++规范中,这样的地方会被解决吗？

^{_{(顺便说一句,这个问题与我几分钟前发布的其他问题完全无关.)}}

如何解决此错误->

当我运行该flutter run命令时，它会出现以下错误。

Error: No pubspec.yaml file found.
This command should be run from the root of your Flutter project.
Do not run this command from the root of your git clone of Flutter.

甚至flutter doctor -v不显示任何错误。

该错误的屏幕截图：

我有两个片段。

第一个片段：

#include <string>

template <typename T>
constexpr bool foo(T&&) {
    return false;
}

int main() {
    std::string a;
    if constexpr (foo(a)) {
    }
}

第二个片段：

#include <string>

template <typename T>
constexpr bool foo(T&&) {
    return false;
}

int main() {
    std::string a;
    std::string& x = a;
    if constexpr (foo(x)) {
    }
}

第一个编译，但第二个不编译（错误消息：错误：'x' 的值在常量表达式中不可用。为什么？为什么a在常量表达式中可用，而x不是？

该命令，用于编译g++ -std=c++17 main.cpp.

在std::priority_queue默认情况下使用std::vector<int>和std::less比较。默认情况下，priority_queue 是最大堆。

top()的文档指出：

所述顶部元件是比较在较高的元件priority_queue，和被从容器中取出时，下一个priority_queue::top将被调用。

这个成员函数有效地调用front了底层容器对象的成员。

因此，默认构造priority_queue的整数构造如下：

auto maxheap = priority_queue<int>();
maxHeap.push(1);
maxHeap.push(3);
cout << maxHeap.top(); // outputs 3

然而，回到对 的描述top()，文档指出，实际上，front底层容器对象上的成员被调用。如果我创建一个向量并使用排序std::less来模拟我们的 maxHeap 的底层容器：

auto vec = vector<int>{3, 1};
sort(vec.begin(), vec.end(), less<int>()); // {1, 3}
cout << vec.front(); // outputs 1

因为std::less按升序排序，调用vec.front()最终返回最小值。

我对priority_queue::top()文档的默认行为和内容的理解存在一些脱节。有人可以向我解释一下吗？

I have read that static variables in c/c++ only initialised once.

But when i tried to experiment with it. I found that they can be initialised multiple times

#include <iostream> 
#include <string> 
using namespace std; 

void demo(int value) 
{ 
    // static variable 
    static int count = 0; 
    count = value; 
    cout << count << " "; 



} 

int main() 
{ 
    for (int i=0; i<5; i++)  
        demo(i+1); 
    return 0; 
} 

In above code my initialised static variable count multiple times.

output …

给定一个由 n 个整数组成的数组，我们如何有效地重新排列其中的数字，使得对于任意两个数字 a[i] 和 a[j] (i < j)，它们的平均值不在两个元素之间？
请注意 (i + 2) <= j < n 其中 n 是数组的长度。数字和平均值只允许使用正整数，即对于 1 和 2，平均值是 1.5，我们需要忽略它。原始数组中的数字是不同的。

让我们举个例子 - 如果给定的数组是 arr = [1, 2, 4, 7]，这不是当前状态下的有效排列，因为 arr[0] 和 arr[3] 的平均值是 4，其中 arr [2]，所以平均 4 位于 1 和 7 之间。但是 [1, 2, 7, 4] 是一个有效的排列。

我想了想，这是我能想出的解决方案，我找不到算法优化的真正范围。我遇到了一些解决方案，例如根据偶数/奇数索引递归地对数组进行分区并将它们合并回来，但它对某些输入不起作用。

from copy import copy
from collections import defaultdict

def arrange_numbers_no_avg_in_between(arr):

    def permutations_helper(i):
        if i == len(arr) - 1:
            num_index_mapping = defaultdict(list)
            for idx, num in enumerate(arr):
                num_index_mapping[float(num)].append(idx)
                
            for …

当你写int i; cin >> i;输入00325或325,两者的投入表现得像i = 325;.但为什么？我认为如果你输入i的价值设定为更自然,那么下一个产生了,而下一个产生了.我知道可以是八进制数,但我现在输入数字作为十进制数(我不使用操纵器).000325cin >>i;i = 0;cin >> i;i = 325;00325oct

什么书面证据保证了这种行为？我快速浏览了N4140,却找不到任何证据.

注意:我想要的是不知道在输出时保持前面的零的方法,这在使用cout << operator时如何用前导零填充int中讨论？.

一旦有人给我这样的句子,我的问题就会得到解决

preceding zeros are ignored when setting a number-type object as the right operand of <<

在一些可靠的文件中.