我经常听到，在编译C和C ++程序时，我应该“始终启用编译器警告”。为什么这是必要的？我怎么做？
有时我也听说我应该“将警告视为错误”。我是不是该？我怎么做？
Java有泛型,C++提供了一个非常强大的编程模型template.那么,C++和Java泛型有什么区别？
当涉及到"问题线"的"隐藏特征"时,没有C++的爱吗？想我会把它扔出去.C++的一些隐藏功能是什么？
我有一些或多或少像这样的代码:
#include <bitset>
enum Flags { A = 1, B = 2, C = 3, D = 5,
E = 8, F = 13, G = 21, H,
I, J, K, L, M, N, O };
void apply_known_mask(std::bitset<64> &bits) {
const Flags important_bits[] = { B, D, E, H, K, M, L, O };
std::remove_reference<decltype(bits)>::type mask{};
for (const auto& bit : important_bits) {
mask.set(bit);
}
bits &= mask;
}
Clang> = 3.6做聪明的事情并将其编译为单个and指令(然后在其他地方内联):
apply_known_mask(std::bitset<64ul>&): # @apply_known_mask(std::bitset<64ul>&)
and qword …我想知道我们是否可以在C/C++中使用递归宏？如果是,请提供示例.
第二件事:为什么我无法执行以下代码？我在做什么错？是因为递归宏吗？
# define pr(n) ((n==1)? 1 : pr(n-1))
void main ()
{
int a=5;
cout<<"result: "<< pr(5) <<endl;
getch();
}
这个问题适用于了解Haskell(或任何其他支持高级类型的函数语言)和C++的人...
是否可以使用C++模板对更高级的kinded类型进行建模？如果是,那怎么样？
编辑:
从该演示文稿由托尼·莫里斯:
高阶多态性:
Java和C#等语言具有一阶多态性,因为它们允许我们对类型进行抽象.例如,
List<A>可以有一个reverse适用于任何元素类型(A)的函数
.
更实用的编程语言和类型系统允许我们在类型构造函数上进行抽象.
此功能称为高阶(或更高阶)多态.
示例:
伪Java,发明了高阶多态性的符号
interface Transformer<X, Y> {
Y transform(X x);
}
interface Monad<M> { // M :: * -> *
<A> M<A> pure(A a);
<A, B> M<B> bind(Transformer<A, M<B>> t, M<A> a);
}
我们知道C++模板元编程是Turing完整的,但预处理器元编程却不是.
C++ 11为我们提供了一种新形式的元编程:constexpr函数的计算.这种计算形式是图灵完备吗？我在想,因为在constexpr函数中允许递归和条件运算符(？:),它会是,但我希望有更多专业知识的人来确认.
人们说这话时意味着什么？对程序员和编译器有什么影响？
我正在尝试创建一个constexpr函数,它将连接Xeo的以下答案来连接任意数量的char数组,它连接两个char数组.
#include <array>
template<unsigned... Is> struct seq{};
template<unsigned N, unsigned... Is>
struct gen_seq : gen_seq<N-1, N-1, Is...>{};
template<unsigned... Is>
struct gen_seq<0, Is...> : seq<Is...>{};
template<unsigned N1, unsigned... I1, unsigned N2, unsigned... I2>
constexpr std::array<char const, N1+N2-1> concat(char const (&a1)[N1], char const (&a2)[N2], seq<I1...>, seq<I2...>){
return {{ a1[I1]..., a2[I2]... }};
}
template<unsigned N1, unsigned N2>
constexpr std::array<char const, N1+N2-1> concat(char const (&a1)[N1], char const (&a2)[N2]){
return concat(a1, a2, gen_seq<N1-1>{}, gen_seq<N2>{});
}
我到目前为止的尝试:
#include <iostream>
#include <array>
template<unsigned... Is> struct seq{}; …我正在尝试使用编译时生成的数组来实现快速函数调度程序,以便能够在运行时在O(1)中使用它.
一些代码行只是为了澄清:
template<int i>
void f()
{
// do stuff
}
// specialized for every managed integer
template<>
void f<1>
{
// do stuff
}
Dispatcher<1,5,100,300> dispatcher;
dispatcher.execute(5); // this should call f<5>()
我们将调度器的输入数量(在这种情况下为4)调用N,并且在这种情况下调度调度器输入(300)的最大值.
我已经能够创建一个大小等于M的数组.这利用了这样一个事实:在运行时你可以做类似的事情:
dispatcher.execute(5) -> internalArray[5]();
这当然是有效的,但对于大尺寸的阵列来说这是不可行的.
最好的方法是仅生成N个元素的数组,并做一些数学技巧将输入索引转换为第二个数组的索引.
在这个例子中,将1,5,100,300分别转换为0,1,2,3.我已经能够做一种预处理方法来改造它们,但我正在寻找一种避免这一步骤的方法.
换句话说,我认为我正在寻找某种最小的完美散列,可以在编译时以非常有效的方式用于我的特定情况(理想情况下没有任何开销,例如:goto:MyInstruction).
我不是在寻找使用虚函数,std :: map或复杂操作的替代方法.
请问是否有不清楚的事情.
PS我正在使用C++ 11,但任何想法都是受欢迎的
[编辑]我知道标签是GCC的语言扩展值.有了这些我可能能够实现我的目标,但需要一个便携式解决方案.