这个问题只是为了让我更好地理解C++中的静态变量.

我认为如果它被声明为静态,我可以在C++中返回对局部变量的引用,因为变量应该在函数返回后生效.为什么这不起作用？

#include <stdio.h>
char* illegal()
{
  char * word = "hello" ;
  return word ;
}

char* alsoNotLegal()
{
  static char * word = "why am I not legal?" ;
  return word ;
}


int main()
{
  // I know this is illegal
  //char * ill = illegal();
  //ill[ 0 ] = '5' ;
  //puts( ill ) ;

  // but why is this? I thought the static variable should "live on" forever -
  char * leg = alsoNotLegal() ; …

我最近安装了Visual Studio 2010 Professional RC来试用它并测试VC++ 2010中实现的一些C++ 0x功能.

我实例化std::vector的std::unique_ptr,没有任何问题.但是,当我尝试通过传递临时值来填充它时push_back,编译器会抱怨复制构造函数unique_ptr是私有的.我尝试通过移动它来插入左值,它工作得很好.

#include <utility>
#include <vector>

int main()
{
    typedef std::unique_ptr<int> int_ptr;

    int_ptr pi(new int(1));

    std::vector<int_ptr> vec;

    vec.push_back(std::move(pi));      // OK
    vec.push_back(int_ptr(new int(2))); // compiler error
}

事实证明,问题既不是unique_ptr也不vector::push_back是VC++在处理rvalues时解决重载的方式,如下面的代码所示:

struct MoveOnly
{
    MoveOnly() {}
    MoveOnly(MoveOnly && other) {}

private:

    MoveOnly(const MoveOnly & other);
};

void acceptRValue(MoveOnly && mo) {}

int main()
{
    acceptRValue(MoveOnly()); // Compiler error
}

编译器抱怨无法访问复制构造函数.如果我将其公开,程序将编译(即使未定义复制构造函数).

我是否误解了rvalue引用的某些内容,或者它是VC++ 2010实现此功能的一个(可能是已知的)错误？

简单的问题,让我给出一些背景知识:

我有一个mpl::vector类型,其中每个类型都有一个id,在运行时我使用mpl::for_each迭代这个向量并找到给定id的匹配类型.但是一旦发现,继续循环是没有意义的,所以 - 问题是,有没有办法摆脱它(没有抛出异常)？

我刚试过这段代码:

struct FaceOfPast
{
    virtual void Smile() = 0;
};

struct FaceOfFuture
{
    virtual void Smile() = 0;
};

struct Janus : public FaceOfPast, public FaceOfFuture
{
    virtual void Smile() {printf(":) ");}
};

...

void main()
{
    Janus* j = new Janus();
    FaceOfFuture* future = j;
    FaceOfPast* past = j;

    future->Smile();
    past->Smile();

    delete j;
}

它的工作原理为目的(输出两个笑脸),但我不认为它甚至应该编译,重新声明的Smile()在Janus被暧昧.

它是如何(以及为什么)有效？

struct CLICKABLE
{
    int x;
    int y;
    BITMAP* alt;
    BITMAP* bitmap;

    CLICKABLE()
    {
        alt=0;
    }
};

CLICKABLE input={1,2,0,0};

此代码给出了以下错误:

无法从大括号括起来的初始化列表转换

有人可以解释一下为什么编译器会给我这个错误,以及我如何解决它？我还在学习这门语言.

在与英特尔IPP库链接时,某些DSP类型的工作负载似乎在英特尔x86 x86_64处理器上显示出非常显着的性能提升.

想知道ARM方面是否有类似的东西？特别是那可能适用于ARM9,ARM11和Cortex-A8/A9(不一定具有相同的性能提升水平).

最后,这个问题可能在这里可能不正确/可接受,所以mods应该留下评论并且我可以编辑它.

我一直在努力阅读IPP的许可协议,但目前尚不清楚Linux上的商业IPP许可证(售价为199美元以上的税)是否可以使用一个个人副本(但可能用于商业用途). ,或者可以将他们的申请与该图书馆联系起来并出售以获取商业利益？或者这需要不同类型的许可证？想知道在英特尔网站上的一个地方问这个问题(没有像联系销售)!

目前,我正在尝试以编程方式将启动打印作业的用户的名称获取到映射的IPP打印机.

我不知道JOB_INFO_2结构的成员pUserName包含用于连接到IPP打印机的用户的名称而不是本地启动打印作业的用户的名称.

为了显示:

看看两者,微软的PrintMon工具和打印机队列,它们都显示相同:

和

尽管另一个用户启动了打印作业,但它们将"uwe_keim"显示为所有者的用户.

这似乎来自用于与IPP打印机进行身份验证的用户的连接凭据:

对于如何/是否有机会获得启动打印作业的实际用户(我需要这个用于在多用户终端环境中运行的应用程序),我真的很无能为力.

总结一下我的问题:

如何获取启动打印作业的用户的名称？(与拥有打印作业的用户的名称相反)

因为C++元编程是功能性的:有没有什么方法可以做任何类似于任何函数式编程语言(例如Haskell的)let或where构造的东西？

我正在使用Boost :: MPL,但希望有更多结构用于更长的元函数.拆分成几个函数很好,但在某些情况下我更喜欢let/where.

我有以下模板化的类结构

struct TraitA{};
struct TraitB{};

template<typename trait>
struct FunctionalityA{};

template<typename trait>
struct FunctionalityB{};

template<typename Func>
struct FuncUserA{};

template<typename Func>
struct FuncUserB{};

template<typename fuser>
struct Host{};

Host类现在可以具有以下类型.

typedef Host<FuncUserA<FunctionalityA<TraitA> > > Host1_t;
typedef Host<FuncUserA<FunctionalityA<TraitB> > > Host2_t;
typedef Host<FuncUserA<FunctionalityB<TraitA> > > Host3_t;
typedef Host<FuncUserA<FunctionalityB<TraitB> > > Host4_t;
typedef Host<FuncUserB<FunctionalityA<TraitA> > > Host5_t;
typedef Host<FuncUserB<FunctionalityA<TraitB> > > Host6_t;
typedef Host<FuncUserB<FunctionalityB<TraitA> > > Host7_t;
typedef Host<FuncUserB<FunctionalityB<TraitB> > > Host8_t;

有没有办法用boost :: mpl创建一个类型列表？目前我甚至没有想法从哪里开始.我的目标是拥有这样的功能:

template<class T>
T* getHost()
{
  typedef boost::mpl::find<HostVector, T>::type MplIter;
  return new …

上下文

我有一个自定义比较器,需要另一个比较器并应用额外的检查:

template <template <typename> class Comparator, typename T>
struct SoftOrder : public std::binary_function<T, T, bool> {
    bool operator()(const T lhs, const T rhs) const {
        return Comparator<T>()(lhs, rhs) && AnotherCheck();
    }
};

我有一个接受比较器的第二类,例如:

template <template <typename> class Comparator>
class Processor { ... };

Processor使用标准比较器(例如std::less)可以很容易地实例化:

Processor<std::less> processor1;
Processor<std::greater> processor2;

然而,实例化并不是那么容易,SoftOrder因为编译器正确地抱怨缺少第二个模板参数:

Processor<SoftOrder<std::less> > processor3; // <-- Fails to compile

当前解决方案

在发布此问题之前,我已经提出了一些解决方案.

第一个解决方案 - 大量派生类

template <typename T>
struct SoftOrderLessThan : public SoftOrder<std::less, T> {};

template <typename …