小编Fri*_*igo的帖子

我刚刚在Windows,MinGW下更新了GCC(我认为)4.5.6到4.6.1.突然,我的NonInstantiable基类(使用public virtual继承以防止实例化)拒绝使用以下和类似的错误消息:

#ifndef Frigo_Lang_NonInstantiable
#define Frigo_Lang_NonInstantiable

namespace Frigo
{
namespace Lang
{

/**
*   Inherit from this class if you want to make a non-instantiable class. Most
*   useful for static classes. It seems every inheritance combination
*   (public/protected/private, non-virtual/virtual) shuts off instantiation in
*   all subclasses as well.
**/

class NonInstantiable
{
private:
/*  Private Classes  */

    /**
    *   A dummy class to prevent GCC warnings about virtual
    *   constructors/destructors and no friends
    **/
    class NonInstantiableDummy { };

/* …

我想提取函数的返回类型.问题是,还有其他函数具有相同的名称但签名不同,我无法让C++选择合适的函数.我知道std :: result_of,但是从几次尝试我得出结论它也遇到了同样的问题.我也听说过涉及decltype的解决方案,但我不知道具体细节.

目前我正在使用模板元编程从函数指针类型中提取返回类型,这对于有限数量的参数(任何非限制解决方案？)都可以正常工作,因为函数指针类型的提取适用于明确的函数.

#include <iostream>

using namespace std;

//  ----

#define resultof(x)     typename ResultOf<typeof(x)>::Type  //  might need a & before x

template <class T>
class ResultOf
{
    public:
        typedef void Type;      //  might need to be T instead of void; see below
};

template <class R>
class ResultOf<R (*) ()>
{
    public:
        typedef R Type;
};

template <class R, class P>
class ResultOf<R (*) (P)>
{
    public:
        typedef R Type;
};

//  ----

class NoDefaultConstructor
{
    public:
        NoDefaultConstructor (int) …

我在Mono的网页上看到他们在精确模式下使用Boehm GC.我也使用Boehm GC与C++,但是,我在其文档或标题中没有发现任何表明精确模式的内容,更不用说如何打开它.

是否有任何信息默认情况下它实际上是否具有精确模式以及如何打开它,或者它只是Mono开发人员的某种修改？

我一直在努力实现一段时间(T*v)函数,到目前为止还没有任何成功.

T v [n]阵列有两种基本的,众所周知的解决方案,一旦阵列衰减成T*v指针,这两种解决方案都是无用的甚至是危险的.

#define SIZE(v) (sizeof(v) / sizeof(v[0]))

template <class T, size_t n>
size_t lengthof (T (&) [n])
{
    return n;
}

有一些涉及包装类和容器的解决方法,如STLSoft的array_proxy,boost :: array,std :: vector等.所有这些都有缺点,缺乏简单性,语法糖和数组的广泛使用.

关于涉及特定于编译器的调用的解决方案存在神话,当delete []需要知道数组的长度时,编译器通常会使用这些调用.根据C++ FAQ Lite 16.14,编译器使用两种技术来了解要释放多少内存:过度分配和关联数组.在过度分配时,它会分配一个更多的单词,并将数组的长度放在第一个对象之前.另一种方法显然将长度存储在关联数组中.是否有可能知道G ++使用哪种方法,并提取适当的数组长度？开销和填充怎么样？对非特定于编译器的代码有什么希望吗？甚至是非平台特定的G ++内置程序？

还有一些解决方案涉及重载operator new []和operator delete [],我实现了:

std::map<void*, size_t> arrayLengthMap;

inline void* operator new [] (size_t n)
throw (std::bad_alloc)
{
    void* ptr = GC_malloc(n);
    arrayLengthMap[ptr] = n;
    return ptr;
}

inline void operator delete [] (void* ptr)
throw ()
{
    arrayLengthMap.erase(ptr);
    GC_free(ptr);
}

template <class T>
inline …

我正在用Java编写基于服务器 - 客户端架构的游戏.

出于设计原因,我想使用异步调用将客户端操作传递给服务器,还使用异步回调将所述操作的结果传递回客户端.异步调用允许缓冲客户端操作.排队缓冲允许简单,基本上是客户端操作的一个线程处理.

目前,我的服务器和客户端代码非常对称.他们创建一个注册表,然后导出并绑定自己.

通过在ConcurrentLinkedQueue中缓冲传入的操作或结果来实现异步性.实际处理由定期运行的线程完成.

但是,当客户端防火墙或NAT后面时,此当前体系结构不起作用.在这种情况下,服务器无法访问客户端以将结果推送给他们.

此外,在当前的体系结构中,服务器不知道哪个客户端发送了给定的动作,除非引入了冗余的认证层或会话处理.这允许伪造的行为和作弊.

我一直在考虑可能的解决方案,但没有找到合适的解决方案:

• 客户端拉取而不是服务器推送.服务器上可能有一个方法,客户端定期调用以获取其结果.但是,这种方法看起来非常难看,它引入了额外的延迟,带宽和时序问题.也不解决行为伪造.直接通知也是非常优选的.

• TCP连接本身允许双向通信,并且可以明确地识别客户端,因此RMI或JRemoting 可能被黑客入侵以支持它,但我不知道如何,并且我不知道任何现有的解决方案.

• 消息传递.我不确定消息传递框架是否支持身份验证/会话或客户端标识.我肯定会失去远程方法.

• 我相信正确的解决方案是找到一个支持上述所有方法的远程方法调用框架.

简而言之,我正在寻找一种方法:

• 异步调用服务器或向其传递消息
• 异步调用客户端或向其传递消息,甚至在防火墙或NAT后面
• 识别发送操作的客户端
• 最好是能够调用方法,而不仅仅是传递消息
• 保持使用JUnit和Mockito(每台机器多个客户端)轻松测试它的能力

是否有任何远程方法调用框架支持这些？哪个最好？

我正在尝试使用Gradle的示例LWJGL应用程序。LWJGL在jar lwjgl-platform-2.8.5-natives-windows.jar中具有OpenGL和OpenAL的本机绑定，但是，Gradle似乎无法识别这一事实。

应用程序插件的distZip任务正确地将所有jar文件复制到zip的lib目录中，但是，在.bat文件中，它仅将上述本地jar放在类路径中，而没有将其作为显式本地传递给Java。

同样，Eclipse项目生成也无法设置给定依赖项的“本机库位置”。

是否有任何官方解决方案可将本机库正确添加到生成的应用程序或Eclipse项目中；如果没有，围绕此限制是否有不错的解决方法？

我的gradle.build：

apply plugin: 'java'
apply plugin: 'application'
apply plugin: 'eclipse'

sourceCompatibility = 1.7

mainClassName = 'org.lwjgl.examples.Game'

repositories {
    mavenCentral();
}

dependencies {
    compile group: 'com.google.guava', name: 'guava', version: 'latest.release'
    compile group: 'org.apache.commons', name: 'commons-lang3', version: 'latest.release'
    compile group: 'org.lwjgl.lwjgl', name: 'lwjgl', version: 'latest.release'

    testCompile group: 'com.jayway.awaitility', name: 'awaitility', version: 'latest.release'
    testCompile group: 'junit', name: 'junit', version: 'latest.release'
    testCompile group: 'org.hamcrest', name: 'hamcrest-all', version: 'latest.release'
    testCompile group: 'org.mockito', name: 'mockito-core', version: 'latest.release'
}

jar {
    baseName …

我有一个命令行 Java SE 应用程序，我想对其进行一些现代化改造。我想在其他 CDI 功能中使用拦截器和依赖注入。然而，该应用程序在设计时并未考虑 CDI 或依赖注入，它广泛使用 new 关键字和构造函数参数，而不是将对象创建委托给 DI 容器。CDI/Weld 不会在使用 new 创建的对象上注入依赖项或运行拦截器，它根本无法处理构造函数参数。一个简化的例子：

class Main {

    @Inject
    private SomeModule someModule;

    public static void main (String[] args) {
        SeContainer container = ... set up CDI container ...
        Main main = container.select(Main.class).get();
        main.main(args);
    }

    @TraceLog
    public Main () {
        ...
    }

    @TraceLog
    public main (String[] args) {
        Encryptor = new Encryptor(args[1], args[2], args[3]);
        encryptor.run();
    }

}

class Encryptor {

    @Inject
    private SomeModule someModule;

    private String inputFile;
    private String outputFile;
    private …

有一个带有clone()函数的Object类可以抛出CloneNotSupportedException*并且声明为此类.CloneNotSupportedException派生自Exception,它派生自Object.

继承需要完整的类型,我们有两个,所以显然我们不能打破那里的循环依赖.成员指针和指针参数是不完整类型的内容,但这对于throw声明来说似乎是不够的,即使我们抛出指针也是如此.

类定义与实现分开,使用前向声明,指向各处.这还不够.

有没有办法打破这种依赖,或者这在C++中是不可能的？