小编Tra*_*kel的帖子

我main.cpp喜欢这样:

#include <boost/python.hpp>

const char* greeting()
{
    return "Hello world?";
}

BOOST_PYTHON_MODULE(test)
{
    using namespace boost::python;

    def("greeting", greeting);
}

和一个CMakeLists.txt文件:

project(test)
cmake_minimum_required(VERSION 2.8)

# get boost
set(Boost_USE_STATIC_LIBS   ON)
set(Boost_USE_MULTITHREADED ON)
find_package(Boost COMPONENTS
                system
                thread
                python
             REQUIRED)
include_directories(${Boost_INCLUDE_DIRS})
link_directories(${Boost_LIBRARY_DIRS})

# get python
find_package(PythonLibs REQUIRED)
include_directories(${PYTHON_INCLUDE_DIRS})
link_directories(${PYTHON_LIBRARIES})

add_library(test SHARED
        main.cpp
    )

我可以跑cmake,make也很好.它libtest.so为我输出一个漂亮的小文件.为了测试它,我有一个像这样的Python脚本:

import libtest

print(libtest.greeting())

在同一目录中运行它libtest.so会产生以下错误:

Traceback (most recent call last):
  File "test.py", line 1, in <module>
    import libtest
ImportError: …

我构建了自己的GCC和库,并将库放在/opt/gcc-4.6.2/lib如此通用的库中,就像libstdc++不干扰系统的其他部分一样.这意味着我必须手动指定库搜索路径:

$> g++-4.6.2 -L/opt/gcc-4.6.2/lib input.cpp

当试图让我的项目用CMake构建时,我似乎无法弄清楚如何告诉CMake搜索该库.该文件说,使用CMAKE_LIBRARY_PATH,这是我用于生成我的Makefile行设置:

$> cmake .. -DCMAKE_CXX_COMPILER=g++-4.6.2 \
            -DCMAKE_LIBRARY_PATH=/opt/gcc-4.6.2/lib

但是,这在简单的程序编译测试中失败了:

# blah blah blah...

/usr/local/bin/g++-4.6.2
CMakeFiles/cmTryCompileExec.dir/testCXXCompiler.cxx.o -o cmTryCompileExec
-rdynamic

/usr/bin/ld: cannot find -lstdc++

# blah blah blah...

我似乎无法找到使CMake的发射所需的巫术-L/opt/gcc-4.6.2/lib的测试编译(我知道CMAKE_LIBRARY_PATH的作品后,该项目建成).如何强制CMake使用替代库路径来链接测试可执行文件？

C++ 11标准包含精彩std::atomic<T>,其中包含以下成员函数:

integral fetch_add(integral, memory_order = memory_order_seq_cst);

然而,似乎缺乏一种add_fetch方法. tbb::atomic<T>重载+=操作符的行为如下add_and_fetch:

 value_type operator+=( D addend ) {
     return fetch_and_add(addend)+addend;
 }

通过经验观察,std::atomic<T>行为方式相同,但我无法在标准中找到它所说的位置,或者只是我的STL实现.标准是否保证了这种行为？

当依赖于稍后定义的函数时,我注意到有关函数查找的奇怪行为:

#include <iostream>

template <typename T>
void foo(const T&)
{
    std::cout << "Basic" << std::endl;
}

template <typename T>
void bar()
{
    T x;
    foo(x);
}

void foo(const int& x)
{
    std::cout << "int:" << x << std::endl;
}

int main()
{
    bar<int>();
}

输出:

Basic

出于某种原因,我期望使用fooinside bar来找到它下面的重载.将重载foo移到上面bar会使输出成为所需int:0(或只是编写声明).

这种相同的行为似乎不适用于重载二元运算符:

#include <iostream>

struct Foo {} foo;

template <typename T>
void operator<<(const Foo&, const T&)
{
    std::cout << "Basic" << std::endl;
}

template …

我正在使用g++-4.6.1 --std=c++0x并收到警告我似乎无法用这段代码解密:

#include <vector>
#include <tuple>

int main()
{
    std::tuple<std::vector<int>, int> t{ {1, 2, 3}, 10};
}

我收到以下警告:

scratch.cpp: In function ‘int main()’:
scratch.cpp:6:55: warning: deducing ‘_U1’ as ‘std::initializer_list<int>’ [enabled by default]
/usr/local/include/c++/4.6.1/tuple:329:9: warning:   in call to ‘std::tuple<_T1, _T2>::tuple(_U1&&, _U2&&) [with _U1 = std::initializer_list<int>, _U2 = int, _T1 = std::vector<int>, _T2 = int]’ [enabled by default]
scratch.cpp:6:55: warning:   (you can disable this with -fno-deduce-init-list) [enabled by default]

看看实施情况:

template<typename _T1, typename _T2>
class tuple<_T1, _T2> : public _Tuple_impl<0, …

我似乎无法正确编译一个简单的Scala项目.该目录看起来像:

.
??? build.gradle
??? src
    ??? Main.scala

该build.gradle很简单:

apply plugin: 'scala'

sourceSets {
    main {
        scala {
            srcDir 'src'
        }
    }
}

它失败了这个迷人的小错误:

* Exception is:
org.gradle.api.tasks.TaskExecutionException: Execution failed for task ':compileScala'.
        at org.gradle.api.internal.tasks.execution.ExecuteActionsTaskExecuter.executeActions(ExecuteActionsTaskExecuter.java:68)
        at org.gradle.api.internal.tasks.execution.ExecuteActionsTaskExecuter.execute(ExecuteActionsTaskExecuter.java:46)
        at org.gradle.api.internal.tasks.execution.PostExecutionAnalysisTaskExecuter.execute(PostExecutionAnalysisTaskExecuter.java:34)
        at org.gradle.api.internal.changedetection.CacheLockHandlingTaskExecuter$1.run(CacheLockHandlingTaskExecuter.java:34)
        at org.gradle.internal.Factories$1.create(Factories.java:22)
        at org.gradle.cache.internal.DefaultCacheAccess.longRunningOperation(DefaultCacheAccess.java:179)
        at org.gradle.cache.internal.DefaultCacheAccess.longRunningOperation(DefaultCacheAccess.java:232)
        at org.gradle.cache.internal.DefaultPersistentDirectoryStore.longRunningOperation(DefaultPersistentDirectoryStore.java:138)
        at org.gradle.api.internal.changedetection.DefaultTaskArtifactStateCacheAccess.longRunningOperation(DefaultTaskArtifactStateCacheAccess.java:83)
        at org.gradle.api.internal.changedetection.CacheLockHandlingTaskExecuter.execute(CacheLockHandlingTaskExecuter.java:32)
        at org.gradle.api.internal.tasks.execution.SkipUpToDateTaskExecuter.execute(SkipUpToDateTaskExecuter.java:55)
        at org.gradle.api.internal.tasks.execution.ValidatingTaskExecuter.execute(ValidatingTaskExecuter.java:57)
        at org.gradle.api.internal.tasks.execution.SkipEmptySourceFilesTaskExecuter.execute(SkipEmptySourceFilesTaskExecuter.java:41)
        at org.gradle.api.internal.tasks.execution.SkipTaskWithNoActionsExecuter.execute(SkipTaskWithNoActionsExecuter.java:51)
        at org.gradle.api.internal.tasks.execution.SkipOnlyIfTaskExecuter.execute(SkipOnlyIfTaskExecuter.java:52)
        at org.gradle.api.internal.tasks.execution.ExecuteAtMostOnceTaskExecuter.execute(ExecuteAtMostOnceTaskExecuter.java:42)
        at org.gradle.api.internal.AbstractTask.executeWithoutThrowingTaskFailure(AbstractTask.java:247)
        at org.gradle.execution.taskgraph.DefaultTaskPlanExecutor.executeTask(DefaultTaskPlanExecutor.java:52)
        at org.gradle.execution.taskgraph.DefaultTaskPlanExecutor.processTask(DefaultTaskPlanExecutor.java:38)
        at org.gradle.execution.taskgraph.DefaultTaskPlanExecutor.process(DefaultTaskPlanExecutor.java:30)
        at org.gradle.execution.taskgraph.DefaultTaskGraphExecuter.execute(DefaultTaskGraphExecuter.java:83)
        at org.gradle.execution.SelectedTaskExecutionAction.execute(SelectedTaskExecutionAction.java:29)
        at …

我正在尝试重新创建一个TypeLoadException用于演示目的,所以我有一个荒谬的愚蠢的库设置,如下所示:

TestProject --> TheLibrary [1.0]
            \-> ProxyForV2 -> TheLibrary [2.0]

TheLibrary 版本1具有以下相关接口:

public interface IConsistentThing
{
    int ConsistentProperty { get; set; }
}

public interface IShrinkingThing
{
    int RemovedProperty { get; set; }
}

虽然版本2 TheLibrary的接口看起来像:

public interface IConsistentThing
{
    int ConsistentProperty { get; set; }
}

public interface IShrinkingThing
{ }

ProxyForV2有这个实现2.0版本的类IShrinkingThing:

public class ShrinkingThingImpl : IShrinkingThing
{
    public int ConsistentProperty { get; set; }
}

因此,TestProject我希望TypeLoadException在某人尝试分配a时ProxyForV2.ShrinkingThingImpl,因为第一个版本的接口具有第二个版本未实现的属性.为了证明这一点,我有一个单元测试,看起来像: …

这个函数的返回值是否由C标准很好地定义？

int foo()
{
    char buff[128];
    // This is the important line:
    if ((void*)buff == (void*)(&buff))
        return 1;
    else
        return 0;
}

结果是foo什么？在gcc和clang,它将永远是1,但我不认为这是由标准保证.

我正在玩Rhino并注意到这种奇怪的行为似乎是运算符优先级:

js> {}+{}
NaN
js> ''+{}+{}
[object Object][object Object]
js> ''+({}+{})
[object Object][object Object]

我希望表达式''+({}+{})可以评估"NaN",因为{}+{}应该首先进行评估,但这不会发生.我在V8和Firefox中对此进行了测试并获得了相同的结果.

为什么Javascript在这种情况下不遵循括号中的标准优先级(4*(1+2)仍然是预期的12)？

假设我有一个漂亮的基类叫做base:

class base
{
public:
    virtual void foo() const = 0;
};

现在,我有一个名为的类foo,我想继承base并覆盖base::foo:

class foo : public base
{
public:
    virtual void foo() const override;
};

这在C++中是非法的,因为不允许将方法命名为与类相同的东西(C++贪婪地认为与类同名的方法是构造函数,不允许返回类型).有没有办法绕过这个不涉及更改类或方法的名称？我希望外部用户能够创建foo类,而不知道有base::foo其他人调用的方法(想象foo可以是名词和动词).