是否有可能在BIGINT没有硬编码的情况下获得类型的最大值？

我知道限制是众所周知的,但我不想硬编码.

给定一组数字a[0], a[1], ..., a[n-1],我们得到这种类型的查询:

输出k- 范围内的最大数字a[i], a[i+1], ..., a[j]

是否可以在n每个查询的多对数时间(in )中回答这些查询？如果没有,是否可以平均结果并仍然获得良好的摊销复杂性？

编辑:这可以使用持久段树来解决 http://blog.anudeep2011.com/persistent-segment-trees-explained-with-spoj-problems/

我想阅读ifstream的内容

#include <vector>
#include <iterator>
#include <fstream>

std::ifstream stream;
std::vector<char> buf(std::istreambuf_iterator<char>(stream),
    std::istreambuf_iterator<char>());

但是当我说:

if(buf.size())
...

我收到一个错误

error: request for member 'size' in 'buf', which is of non-class type 'std::vector<char, std::istreambuf_iterator<char, std::char_traits<char> > >(std::istreambuf_iterator<char, std::char_traits<char> >, std::istreambuf_iterator<char, std::char_traits<char> > (*)())'

所以编译器认为我声明了一个函数而不是一个函数vector<char>.我怎样才能使它工作？

我编译-std=c++0x与g++-4.6.3

这个问题更多的是解析消歧而不是阅读文件.

我想在一个容器中存储可变数量的互斥锁，比如 vector 或 deque。

在其中一个用例中，我需要可靠且无死锁地锁定所有互斥锁。我还希望有异常安全保证，如果抛出异常，所有互斥锁就好像没有发生锁定一样。

我正在尝试执行以下操作：

std::vector<std::mutex> locks_(n);
std::vector<std::lock_guard<std::mutex> > guards(n);
for(int i = 0; i < n; i++) {
    std::lock_guard<std::mutex> guard(locks_[i]);
    guards.emplace_back(std::move(guard));
}

但它没有编译，给我：

/usr/include/c++/4.8/ext/new_allocator.h:120:4: 错误：使用已删除的函数 'std::lock_guard<_Mutex>::lock_guard(const std::lock_guard<_Mutex>&) [with _Mutex = std::mutex]'

我想当 lock_guards 被销毁时也可能有问题，因为与构造相比，顺序必须颠倒，但标准为我们节省了：

delete-expression 将为要删除的对象或数组元素调用析构函数（如果有）。在数组的情况下，元素将按地址递减的顺序销毁（即，按照其构造函数完成的相反顺序；参见 12.6.2）。

这种方法是否存在任何潜在的缺陷，如何使其发挥作用？

编辑

实际上我错了，似乎 vector 并不能保证特定的破坏顺序。请参阅此问题：std::vector 元素的销毁顺序

编辑2

问：如果用例是：

所有互斥锁都由不同的线程以任何顺序锁定/解锁（但是这些线程中的每一个一次仅使用 1 个互斥锁），但在某些时候我需要在另一个线程中以安全的方式锁定所有互斥锁。

我想以类似于gradle.properties或的方式在gradle中设置属性(例如来自settings.gradle)-D.可能吗？

以下代码演示了我正在尝试做什么,但它不起作用:

import org.gradle.internal.os.OperatingSystem
def getArchitecture() {
    return System.getProperty("os.arch")
}

def getName() {
    if(OperatingSystem.current().isMacOsX()) {
        return "darwin"
    } else if(OperatingSystem.current().isLinux()) {
        return "linux"
    } else {
        throw Exception("The operating system you use is not supported.")
    }
}

allprojects {
    ext {
        // this variable has to be visible from all the projects 
        // and .gradle files in the same way as if it was set 
        // from gradle.properties file
        buildMachine = getName() + "_" + getArchitecture() …

在c ++ 11标准下是否存在以下未定义的行为:

(试图获取字符串的内部缓冲区的地址)

std::string s;
... = &s[0];

例如什么时候s是空的？

我知道我们有c_str(), data(),但不过.

注意

这是来自与某人的辩论,这不是为了促进hacky编码

我想实现一个字典,可以对插入的键进行某些检查,例如请参见下文:

from collections import defaultdict

class CheckingDict(defaultdict):

    def __init__(self, *args, **kwargs):
        super(CheckingDict, self).__init__(*args, **kwargs)

    def __setitem__(self, key, value):
        if not super(CheckingDict, self).__missing__(key):
            raise ValueError("Key {key} is already present".format(key=key))
        else:
            return defaultdict.__setitem__(self, key, value)

a = CheckingDict(lambda: None)
a[1] = 1

上面代码的问题是给了我无限递归.所以问题是为什么以及如何正确地做到这一点？

我不想使用合成,因为要获得defaultdict我需要编写更多代码的所有功能.

这个问题是针对 gradle (>= 2.4)。我想编写一个如下的自定义任务：

https://docs.gradle.org/current/userguide/custom_tasks.html

class GreetingTask extends DefaultTask {
    @TaskAction
    def greet() {
        println 'hello from GreetingTask'
    }
}

task hello(type: GreetingTask)

如何在执行阶段运行此任务？正在传递一个空的闭包

<< {

}

唯一的解决办法？

编辑

该任务应该用于具有多个任务作为依赖项的多项目构建。

我希望该命令gradle build可以通过说类似的话来构建所有项目

`build.dependsOn(hello)`

但似乎任务 hello 在构建的配置阶段被调用。

在我的代码中的一些在线判断我有以下内容:

vector<int> arr(1 << 20);

int p;
cin >> p >> arr[p];

这给了我一个分段错误,当编译与判断(虽然我无法访问他们的机器)编译器g ++ 4.9.2但不在我的本地 Apple LLVM version 6.0 (clang-600.0.57)

但是把它写成:

int p;
cin >> p;
cin >> arr[p];

对法官也很好.这是一个已知的东西/错误吗？为什么第一个版本不按预期工作？

我有一个讨论与主题是否条款队友clause和expression可以互换使用.例如,调用代表expression a=b(例如,参与语句SELECT * WHERE expression)子句的变量是正确/通用的吗？

编辑

这将是有益的是有人能给出什么确切的定义clause,expression并statement在SQL世界.

我的bash文件中有以下内容:(在任何情况下,一旦bash脚本结束,我想杀死一个Web服务器)

python -m SimpleHTTPServer 12345 &
trap "kill $!" EXIT

我想知道这有多安全/普遍？什么时候会$!被评估(我很确定这发生在声明的地方,但仍然需要建议)？