小编Rya*_*ing的帖子

是否有一行宏定义来确定机器的字节顺序.我使用以下代码,但将其转换为宏将太长.

unsigned char test_endian( void )
{
    int test_var = 1;
    unsigned char test_endian* = (unsigned char*)&test_var;

    return (test_endian[0] == NULL);
}

是否有一种安全,可移植的方法来确定(在编译期间)我的程序正在编译的平台的字节顺序？我在用C写作

[编辑]感谢您的回答,我决定坚持运行时解决方案!

据我所知,super关键字调用一个方法,该方法与当前类的超类中的当前方法具有相同的名称.在autoload方法下面,有一个电话super.我想知道在哪个超类中我会找到一个具有相同名称的方法或者super这里要做的调用

module ActiveSupport
  module Autoload
    ...      
    def autoload(const_name, path = @@at_path)
      full = [self.name, @@under_path, const_name.to_s, path].compact.join("::")
      location = path || Inflector.underscore(full)

      if @@eager_autoload
        @@autoloads[const_name] = location
      end
      super const_name, location
    end
   .... 
  end
end

module ActiveRecord
  extend ActiveSupport::Autoload
  ...
  autoload :TestCase
  autoload :TestFixtures, 'active_record/fixtures'
end

此代码来自rails master分支.非常感谢.

我需要使用小数.在我的程序中,用户需要输入一个带小数的数字来转换该数字.

问题是:如果我尝试将参数转换为数字,我会得到一个没有小数的整数.

# ARGV[0] is: 44.33

size = ARGV[0]

puts size.to_i
# size is: 44
# :(

回顾关于折叠的C++ 17 论文(以及cppreference),我很困惑为什么选择只与运营商合作？乍一看似乎(... + args)只是通过+在元素之间推一个标记来扩展它更容易args,但我不相信这是一个伟大的决定.

为什么二元lambda表达式不能同样工作并遵循与上面相同的扩展？对我来说,在不支持任意可调用语言的情况下将折叠语法添加到语言中是很不可思议的,语法是否允许使用我只是没有看到的方法？

更新:这适用于min()具有clang 的可变函数

template <typename T>
struct MinWrapper {
    const T& obj;
};

template <typename T, typename U, typename V=std::common_type_t<T,U>>
constexpr MinWrapper<V> operator%(
        const MinWrapper<T>& lhs, const MinWrapper<U>& rhs) {
    return {lhs.obj < rhs.obj ? lhs.obj : rhs.obj};
}


template <typename... Ts>
constexpr auto min(Ts&&... args) {
    return (MinWrapper<Ts>{args} % ...).obj;
}

如果我迭代一次哈希,然后在不修改内容的情况下再次执行,键是否保证以相同的顺序出现？

快速测试表明:

> h = {'a' => 1, 'b' => 2, 'c' => 3}
> 100_000.times.map { h.to_s == h.to_s }.all?
=> true

另一个问题,如果允许上面的话,我可以迭代它只更改值,而不添加任何新键,并且键的顺序是否保持不变？

类似于这个python问题:如果未修改,dicts是否保留迭代顺序？

与提议的副本不同,我对元素是否具有完全指定的顺序不感兴趣,只有两个连续迭代没有修改的限制提供相同的序列.

更新: 条件显式使其成为C++ 20草案.更多关于cppreference

该cppreference的std ::元组构造页面有一堆的C++ 17的笔记说这样的话:

这个构造函数是explicitif和only if std::is_convertible<const Ti&, Ti>::value至少为falsei

如何编写有条件显式的构造函数？想到的第一种可能性是,explicit(true)但这不是合法的语法.

尝试enable_if失败:

// constructor is explicit if T is not integral
struct S {
  template <typename T,
            typename = typename std::enable_if<std::is_integral<T>::value>::type>
  S(T) {}

  template <typename T,
            typename = typename std::enable_if<!std::is_integral<T>::value>::type>
  explicit S(T) {}
};

有错误:

error: ‘template<class T, class> S::S(T)’ cannot be overloaded
explicit S(T t) {}

我有一个类模板Obj和一个函数模板make_obj. Obj有一个private构造函数定义,它引用其绑定的模板类型.

template <typename T>
class Obj {
  private:
    T& t;
    Obj(T& t)
        : t{t}
    { }
};

template <typename T>
Obj<T> make_obj(T& t) { 
    return {t};
}

我想要的是声明make_obj函数a,friend以便它可以创建Obj,但没有其他人可以(除了通过复制ctor).

我已经尝试了几个朋友声明,包括

friend Obj make_obj(T&);

和

template <typename T1, typename T2>
friend Obj<T1> make_obj(T2&);

后者是完成该类make_obj朋友的所有模板实例化的不太理想的尝试Obj.但是在这两种情况下我都会得到同样的错误:

error: calling a private constructor of class 'Obj<char const[6]>'
    return {t};
           ^

note: in instantiation of function template specialization
      'make_obj<const …

有一些Stack Overflow用户强烈主张在编写函数时总是使用新的C++ 11尾随返回类型约定,例如main()->int.我可以看到优点,因为它使符号统一.但是,当声明一个函数指针时,我找不到任何使用尾随返回形式的方法,即可以声明

typedef int(*fp)(int);

要么

using fp = int(*)(int);

一个函数指针取一个int并返回一个int.

有没有办法在声明这样的函数指针时使用新的尾部返回语法？例如,像

using fp = (*)(int)->int;

但这不编译.如果没有,新语法不适用于函数指针是否有原因？

我一直在玩定义中的推断返回类型,它们解析为与声明相同的类型.这有效:

template <typename>
struct Cls {
  static std::size_t f();
};

template <typename T>
decltype(sizeof(int)) Cls<T>::f()  { return 0; }

但是,如果我更改定义的东西,应该更换等同sizeof(int)与sizeof(T) 失败

template <typename T>
decltype(sizeof(T)) Cls<T>::f() { return 0; }

gcc的错误(clang几乎相同):

error: prototype for ‘decltype (sizeof (T)) Cls<T>::f()’ does not match any in class ‘Cls<T>’
 decltype(sizeof(T)) Cls<T>::f() { return 0; }
                     ^~~~~~
so.cpp:4:24: error: candidate is: static std::size_t Cls<T>::f()
     static std::size_t f();
                        ^

函数参数类型出现同样的问题:

template <typename>
struct Cls {
  static void f(std::size_t);
};

template <typename T>
void …