小编gaa*_*kam的帖子

我是对的,这段代码引入了未定义的行为？

#include <stdio.h>
#include <stdlib.h>

FILE *f = fopen("textfile.txt", "rb");
fseek(f, 0, SEEK_END);
long fsize = ftell(f);
fseek(f, 0, SEEK_SET);  //same as rewind(f);

char *string = malloc(fsize + 1);
fread(string, fsize, 1, f);
fclose(f);

string[fsize] = 0;

我之所以要问的是,这段代码是作为以下问题的一个被接受且高度评价的答案发布的:C编程:如何将整个文件内容读入缓冲区

但是,根据以下文章:如何在C++中读取整个文件到内存中(尽管它的标题,它也处理C,所以坚持我):

假设您正在编写C,并且您有FILE*(您知道指向文件流,或者至少是可搜索流),并且您想要确定在缓冲区中分配多少个字符来存储流的全部内容.你的第一直觉可能是编写这样的代码:

// Bad code; undefined behaviour
fseek(p_file, 0, SEEK_END);
long file_size = ftell(p_file);

Run Code Online (Sandbox Code Playgroud)

似乎是合法的.但后来你开始变得怪异了.有时报告的大小大于磁盘上的实际文件大小.有时它与实际文件大小相同,但您读入的字符数不同.这到底是怎么回事？

有两个答案,因为它取决于文件是以文本模式还是以二进制模式打开.

万一你不知道区别:在默认模式 - 文本模式 - 在某些平台上,某些字符在阅读过程中会以各种方式被翻译.最着名的是,在Windows上,新行在\r\n写入文件时会被翻译,并在读取时以其他方式翻译.换句话说,如果文件包含Hello\r\nWorld,则将其读作Hello\nWorld; 文件大小为12个字符,字符串大小为11.鲜为人知的是 0x1A(或Ctrl-Z)被解释为文件的结尾,因此如果文件包含Hello\x1AWorld,则将其读作Hello.此外,如果内存中的字符串是,Hello\x1AWorld …

如标题中所示.作为练习,我想创建一个int来强制对其值进行约束,并且不允许将其设置为超出其指定范围的值.

以下是我尝试解决此问题的方法:

#include <cassert>
#include <cstdint>
#include <iostream>
using namespace std;

int main();

template<typename valtype, valtype minval, valtype maxval>
class ConstrainedValue
{
  valtype val;

  static bool checkval (valtype val)
  {
    return minval <= val && val <= maxval;
  }

public:
  ConstrainedValue() : val{minval} // so that we're able to write ConstrainedValue i;
  {
    assert(checkval(val));
  }

  ConstrainedValue(valtype val) : val{val}
  {
    assert(checkval(val));
  }

  ConstrainedValue &operator = (valtype val)
  {
    assert(checkval(val));
    this->val = val;
    return *this;
  }

  operator const valtype&() // Not …

我在考虑这样的事情:

#include <iostream> // Comment

那么,cppreference.com(http://en.cppreference.com/w/cpp/preprocessor)声称:

预处理指令控制预处理器的行为.每个指令占用一行,格式如下:

#character preprocessing指令(define,undef,include,if,ifdef,ifndef,else,elif,endif,line,error,pragma之一)参数(取决于指令)换行符

这么好,给出了整条生产线的完整规范,并且没有地方可以在那里发表评论.在这些方面不允许建议评论.

但是,即使使用-Wall -Wextra -Wpedantic,g ++和clang ++都接受这样的输入.此外,cplusplus.com提供了此类评论的示例:http://www.cplusplus.com/reference/istream/istream/operator%3E%3E/

更让我感到困惑的是,有人告诉我" 在#行中发表评论仍然有效,但它们可能并不意味着你想要的东西 ".我不确定这是怎么回事,因为根据http://en.cppreference.com/w/cpp/language/translation_phases评论在启动预处理器之前被空格字符替换 - 所以如果它们被允许的话#行,它们怎么会干扰这种#行的语义？

从这个问题:"var FOO = FOO || {}"(将变量或空对象分配给该变量)在Javascript中是什么意思？

我已经知道这var FOO = FOO || {}基本上意味着"如果FOO存在,那就保持不变,否则就把它变成空物".

但是怎么样？

这就是我解析这种语法的方法:

var FOO = (FOO || {})

所以:如果FOO存在AND并且计算布尔值为True,那么(FOO || {})将返回True,因此最终FOO将被完全覆盖并且从现在开始将保持布尔值True.

否则(FOO || {})将返回到{}evalueates的任何布尔值.由于空对象,{}总是计算为True ...

那么在任何情况下(FOO || {})都应评估为True,所以...

在任何可能的情况下,在评估之后var FOO = FOO || {},FOO应该保持普通的布尔值True,而不管之前持有的是什么.基本上,根据我的理解,var FOO = FOO || {}应该相当于var FOO = True.

我的错误在哪里？

我对Haskell的解析规则感到困惑。

这很漂亮：

n = 5
m = 6
b = case (n, m) of
  (5, 6) -> True
  _ -> False

main = print b

让我们把它复杂化得很小，让我们let在混合物中添加一个：

b =
  let res = case (n, m) of
    (5, 6) -> True
    _ -> False
  in not res

（注意，为了简便起见，我省略的定义n，m并main从现在开始，他们进行相同的，我只是改变b）

糟糕，这里的问题：

wtf.hs:5:5: error: parse error on input ‘(’
Failed, modules loaded: none.

我不知道，也许那是我没有得到的某种奇怪的缩进规则。好的，让我们用括号括起来：

b =
  let res = case (n, m) of {
    (5, …

我记得在SO上读过，CSS中一般应避免像素分数，因为浏览器倾向于将其舍入为完整像素。

实际上，以下示例显示了0.3像素如何舍入为完整像素：

span {
  border: 0.3px solid black;
}

<span>Lorem ipsum.</span>

我很惊讶，因为我似乎找到了一个反例：

span {
  color: white;
  -webkit-text-stroke: 0.3px black;
}

<span>Lorem ipsum.</span>

与1px：

span {
  color: white;
  -webkit-text-stroke: 1px black;
}

<span>Lorem ipsum.</span>

我不是在抱怨的是它发生，相反它几乎是一个救星我，但我想知道为什么它会发生。

• 浏览器何时将像素分数四舍五入为完整像素？什么时候不呢？这里有什么规则？
• 我可以依靠浏览器不四舍五入0.3px到1px在上面的例子？这种行为在浏览器之间是否一致？还是依靠这种行为来解决麻烦？
• 这怎么发生？在笔记本电脑上，像素（像素）应该不受硬件（显示器）限制的约束吗？

这个C++代码是否正确？

const size_t tabsize = 50;
int tab[tabsize];

问题是我已经看到了很多关于这件事的相互矛盾的意见.即使是## c ++ IRC频道和节目论坛的人也要求完全不同的东西.

有人说上面的代码是正确的.

其他人认为它不是,它应该是这样的:

constexpr size_t tabsize = 50;
int tab[tabsize];

由于我对"C++专家"的观点存在冲突已经足够困惑,我可以请一个合理的备份答案吗？非常感谢!

cppreference.com(http://en.cppreference.com/w/cpp/types/enable_if#Notes)指出:

一个常见的错误是声明两个仅在默认模板参数上有所不同的函数模板.这是非法的,因为默认模板参数不是函数模板签名的一部分,并且声明具有相同签名的两个不同函数模板是非法的.

struct T {
    enum { int_t,float_t } m_type;
    template <typename Integer,
              typename = std::enable_if_t<std::is_integral<Integer>::value>
    >
    T(Integer) : m_type(int_t) {}

    template <typename Floating,
              typename = std::enable_if_t<std::is_floating_point<Floating>::value>
    >
    T(Floating) : m_type(float_t) {} // error: cannot overload
};

Run Code Online (Sandbox Code Playgroud)

那么真实......那么解决这个问题并实际实现上述错误代码无法实现的正确方法是什么？

我最近发现了一件奇怪的事情.似乎计算Collat​​z序列长度完全没有缓存比使用缓存所有元素快 2倍.std::unordered_map

注意我确实从问题提示中是否gcc std :: unordered_map实现缓慢？如果是这样 - 为什么？我试着用这些知识来std::unordered_map表现我的能力(我使用g ++ 4.6,它确实比g ++的最新版本表现更好,我试着指定一个声音的初始桶数,我使它完全等于最大值地图必须持有的元素数量).

相比之下,使用std::vector缓存一些元素几乎比没有缓存快17倍,比使用缓慢快近40倍std::unordered_map.

我做错了什么,或者这个容器是慢的,为什么？可以让它表现得更快吗？或者,哈希映射本质上是无效的,应该尽可能避免在高性能代码中使用？

有问题的基准是:

#include <iostream>
#include <unordered_map>
#include <cstdint>
#include <ctime>

std::uint_fast16_t getCollatzLength(std::uint_fast64_t val) {
    static std::unordered_map <std::uint_fast64_t, std::uint_fast16_t> cache ({{1,1}}, 2168611);

    if(cache.count(val) == 0) {
        if(val%2 == 0)
            cache[val] = getCollatzLength(val/2) + 1;
        else
            cache[val] = getCollatzLength(3*val+1) + 1;
    }

    return cache[val];
}

int main()
{
    std::clock_t tStart = std::clock();

    std::uint_fast16_t largest …

请考虑以下代码:

pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr);
pthread_mutexattr_setrobust(&attr, PTHREAD_MUTEX_ROBUST);

pthread_mutex_t mut;
pthread_mutex_init(&mut, &attr);

pthread_mutexattr_destroy(&attr);

pthread_mutex_lock(&mut);

这段代码有效吗？

如果允许互斥锁包含对其初始化的属性对象的引用,那么我想pthread_mutexattr_destroy(&attr)在使用互斥锁之前我可能不会调用.