小编Ari*_*Ari的帖子

这不编译:

template<class X> struct A {
   template<int I> void f() {}
};

template<class T> void g()
{
   A<T> a;
   a.f<3>();  // Compilation fails here (Line 18)
}

int main(int argc, char *argv[])
{
   g<int>();  // Line 23
}

编译器(gcc)说:

hhh.cpp:在函数'void g()'中:

hhh.cpp:18:错误:')'令牌之前的预期primary-expression

hhh.cpp:在函数'void g()[with T = int]'中:

hhh.cpp:23:从这里实例化

hhh.cpp:18:错误:无效使用成员(你忘了'&'？)

谁能解释为什么会这样？有没有办法让它发挥作用？

最近我遇到了Builder设计模式.似乎不同的作者使用"Builder模式"来引用不同的风格,所以让我描述一下我所询问的模式.

我们有一个用于创建产品的算法,即不同类型的对象.在足够高的抽象级别,所有产品类型的算​​法都是相同的,但每种产品类型都需要对每个算法的抽象步骤进行不同的实现.例如,我们可能有以下蛋糕烘焙算法:

 1. Add liquids.
 2. Mix well.
 3. Add dry ingredients.
 4. Mix well.
 5. Pour batter into baking pan.
 6. Bake.
 7. Return baked cake.

不同的蛋糕将需要这些步骤的不同实施,即,使用什么液体/干燥成分,混合的速度,烘烤多长时间等.

模式说是这样做的.对于每个产品,我们创建一个具体的构建器类,其中包含上述每个步骤的实现.所有这些类都派生自一个抽象构建器基类,它本质上是一个接口.因此,例如,我们将有一个抽象基类CakeBaker与纯虚方法AddLiquid(),MixLiquids()等等.具体的蛋糕面包师将是具体的子类,例如,

class ChocolateCakeBaker : public CakeBaker {
public:
   virtual void AddLiquids()
   {
        // Add three eggs and 1 cup of cream
   }

   virtual void AddDryIngredients()
   {
       // Add 2 cups flour, 1 cup sugar, 3 tbsp cocoa powder,
       // 2 …

alloca是C++标准的一部分吗？

我想确定列表是否包含某个字符串,所以我使用生成器表达式,如下所示:

g = (s for s in myList if s == myString)
any(g)

当然我想内联这个,所以我这样做:

any((s for s in myList if s == myString))

然后我认为单个parens会更好看,所以我尝试:

any(s for s in myList if s == myString)

并不是真的期待它的运作.惊喜!它呢!

那么这个合法的Python还是我的实现允许的东西？如果它是合法的,这里的一般规则是什么？

我想定义一个可以在不同位置(在文件范围内)调用的宏,以便创建执行某些操作的函数.(在下面的例子中,函数只是打印一条消息,但当然我的真正意图是做一些其他有用的东西.)挑战是我想要一些"经理"功能(在我的例子中它只会是main())以某种方式成功在所有调用它们(以任何顺序),没有任何代码依赖于宏调用(当然,除了宏调用本身).我的意思是,一旦编写了文件,另一个程序员就能够在不同的地方插入一些新的宏调用或者删除一些现有的调用,代码仍然可以在没有任何进一步改变的情况下工作.我意识到这可以使用静态对象完成,但我想探索一种不同的方法.我将使用一些模板技巧和__LINE__单调增加的事实.

#include <iostream>
using namespace std;

template<int i>
inline void f()
{
   f<i-1>();
}

#define START_REGISTRATION                                \
template<>                                                \
inline void f<__LINE__>() {}  /* stop the recursion */    \
template<> void f<__LINE__>()  /* force semicolon */

#define REGISTER(msg)                                     \
template<>                                                \
inline void f<__LINE__>()                                 \
{                                                         \
   cout << #msg << endl;                                  \
   f<__LINE__ - 1>();                                     \
}                                                         \
template<> void f<__LINE__>()  /* force semicolon */

// Unrelated code ...

START_REGISTRATION;

// Unrelated code ...

REGISTER(message …

我有一个类,其中一个bool数据成员未被构造函数初始化.如果我做

cout << x.myBoolDataMember;

x这个类的对象在哪里bool尚未初始化,我有时得到一个随机数而不是0或1.(我正在使用gcc.)这种行为是否符合Standard？

我最近读过一些关于使用大括号来允许多个用户定义转换的地方(不记得在哪里),但是构造函数转换和转换方法转换之间似乎存在差异,我不明白.

考虑:

#include <string>

using ::std::string;

struct C {
  C() {}
};

struct A {
  A(const string& s) {}  // Make std::string convertible to A.
  operator C() const { return C(); }  // Makes A convertible to C.
};

struct B {
  B() {}
  B(const A& a) {}  // Makes A convertible to B.
};

int main() {
  B b;
  C c;

  // This works.
  // Conversion chain (all thru ctors): char* -> string -> A -> B
  b = …

考虑:

#include <iostream>

using namespace std;

struct A {
  virtual void f() { cout << "A::f" << endl; }
  virtual void f() const { cout << "A::f const" << endl; }
};

struct B : public A {};

struct C : public A {
   virtual void f() { cout << "C::f" << endl; }
};


int main()
{
   const B b;
   b.f();   // prints "A::f const"

   const C c;
   c.f();
   // Compile-time error: passing ‘const C’ as ‘this’ argument of …

假设我有A成员函数的类,int f() { return m_; }其中m_是数据成员.我有一个vector<A>被叫vec,我想m_在vec使用中找到具有最大价值的对象std::max_element.我可以用lambda做到这一点:

auto cmp = [] (A& x, A& y) { return x.f() < y.f(); };
A& max_elem = *std::max_element(vec.begin(), vec.end(), cmp);

是否有一些bind(或某些这样的)技巧可以让我在没有lambda的情况下完成它并且不从头开始定义我自己的比较器？请不要建议更好的方法来解决最大发现问题.这只是一个例子.一般的问题是如何包装一个带有多个参数的函数对象(例如,std::less<int>我将用作上例中的比较器),使得发送给它的参数通过其他函数(或成员)在达到它之前.

我想让一些文本看起来是半透明的,但不是以叠加的方式(最终变成实体),只是永久半透明.更复杂的是,有关文本是以下内容的一部分matrix:

$
\begin{matrix}
          & \{-2,3,5,0,8\} & \\
    \{-2,3,5,0\} & & \{-2,3,5,8\} \\
          & \{-2,3,5\} &
\end{matrix}
$

我希望矩阵中的第三行是半透明的.有没有办法做到这一点？