小编Bjö*_*lex的帖子

在多线程场景中,我有一个这样的方法:

bool WaitForChange( time_duration WaitTime ) const;

此方法等待,直到对象的状态发生变化并返回true,或者直到超时超时(你怎么说？)并返回false.

我的直觉是,这const是为了防止方法本身产生不必要的副作用,所以这很好.但话说回来,一些用户可能认为状态无法改变,因为声明了方法const.该用户是愚蠢的,还是应该将该方法const设为非,以避免混淆？

我想要这样的东西:

public void CopyIteratorIntoList(Iterator<Foo> fooIterator) {
    List<Foo> fooList = new ArrayList<Foo>();
    fooList.addAll(fooIterator);
}

这相当于:

public void CopyIteratorIntoList(Iterator<Foo> fooIterator) {
    List<Foo> fooList = new ArrayList<Foo>();
    while(fooIterator.hasNext())
        fooList.add(fooIterator.next());
}

API中是否有任何方法可以实现,或者这是唯一的方法吗？

我有一个长期运行的Python脚本,我从命令行运行.该脚本将进度消息和结果写入标准输出.我想捕获脚本写入文件中标准输出的所有内容,但也要在命令行中查看它.或者,我希望输出立即转到文件,因此我可以tail用来查看进度.我试过这个:

python MyLongRunngingScript.py | tee log.txt

但它不会产生任何输出(只是运行脚本会产生预期的输出).谁能提出一个简单的解决方案？我使用的是Mac OS X 10.6.4.

编辑我print在脚本中用于输出.

我有一个函数,在最简单的情况下,它可以在一个可迭代的项目上运行.

def foo(items):
    for item in items:
        # do stuff

有时候,我不想直接传递一个可迭代的项目,而是一个提供获取可迭代的方法的对象:

def foo(obj):
    for item in obj.iteritems():
        # do same stuff as above

我可以像这样合并这两种情况:

def foo(obj):
    try:
        items = obj.iteritems()
    except ValueError:
        items = obj
    for item in items:
        # do stuff

这很好用.现在我得到第三个用例,如下所示:

def foo(objs):
    for item in itertools.chain.from_iterable(obj.iteritems() for obj in objs):
        # do same stuff again

我仍然可以使用这种try-except方法,因为接口是不兼容的.但是,嵌套的try catch会变得非常难看.当我想添加第四个用例时更是如此.有没有办法解决这个问题而不嵌套try-blocks？

请考虑以下代码:

from numpy import log2
import matplotlib.pyplot as plt

xdata = [log2(x)*(10/log2(10)) for x in range(1,11)]
ydata = range(10)
plt.plot(xdata, ydata)
plt.show()

这会产生以下情节: 我的问题是,我该如何修改它,以便绘图与输入的数据完全相同,显示为一条直线？这基本上需要适当地缩放x轴,但我无法想象如何做到这一点.这样做的原因是我显示的函数在开始时变化很小,但在有效间隔结束时开始更多地波动,所以我希望在结束时有更高的水平分辨率.如果有人可以为我的方法提出替代解决方案,请随意这样做!

请考虑以下代码:

#include <sstream>
#include <iostream>

class Foo : public std::stringstream {
public:
    ~Foo() { std::cout << str(); }
};

int main()
{
    Foo foo;
    foo << "Test1" << std::endl;

    Foo() << "Test2" << std::endl;

    return 0;
}

当我执行此操作时,它给了我:

004177FC
Test1

我不明白为什么第二个例子给我带来胡言乱语.临时应该存在直到整个表达式被评估,那么为什么它与第一个例子的行为不一样？

#include <iostream> 
#include <vector>
using namespace std;

class Base
{
public:
      void Display( void )
      {
            cout<<"Base display"<<endl;
      }

      int Display( int a )
      {
            cout<<"Base int display"<<endl;
            return 0;
      }

};

class Derived : public Base
{
public:

      void Display( void )
      {
            cout<<"Derived display"<<endl;
      }
};


void main()
{
   Derived obj;
   obj.Display();  
   obj.Display( 10 );
}

$test1.cpp: In function ‘int main()’:  
test1.cpp:35: error: no matching function for call to ‘Derived::Display(int)’  
test1.cpp:24: note: candidates are: void Derived::Display()

在评论时obj.Display(10) …

在试图找到这个问题的答案时,我写了这个小测试程序:

#include <iostream>
#include <fstream>
#include <vector>
#include <iterator>
#include <algorithm>

void writeFile() {
    int data[] = {0,1,2,3,4,5,6,7,8,9,1000};

    std::basic_ofstream<int> file("test.data", std::ios::binary);
    std::copy(data, data+11, std::ostreambuf_iterator<int>(file));
}

void readFile() {
    std::basic_ifstream<int> file("test.data", std::ios::binary);
    std::vector<int> data(std::istreambuf_iterator<int>(file),
        (std::istreambuf_iterator<int>()));

    std::copy(data.begin(), data.end(), 
              std::ostream_iterator<int>(std::cout, " "));
    std::cout << std::endl;
}


int main()
{
    writeFile();
    readFile();

    return 0;
}

它按预期工作,将数据写入文件,并在读取文件后,正确打印:

0 1 2 3 4 5 6 7 8 9 1000

但是,我不确定是否存在任何陷阱(除了字节问题,在处理二进制数据时总会有这些问题)？这是允许的吗？

考虑以下程序:

#include <iostream>

typedef void (*fptr)(...);

void foo(fptr func) {
    (*func)(12);
}

void bar(int x) {
    std::cout << "bar : " << x << std::endl;
}

int main() {
    foo(fptr(bar));
}

这在至少一个编译器上编译,运行和打印bar : 12 :)我在一些我应该维护的遗留代码中找到了这个,我想知道这是否安全/定义？

bar与类型不匹配fptr,因此使其工作的唯一方法是使用不安全的强制转换.我想这取决于省略号 - 魔法如何在内部工作,那么这是以某种方式定义的吗？

我需要在servlet中重用最初为Eclipse RCP应用程序开发的代码(即盒装为Eclipse插件/ OSGi包).

在阅读了很多博客文章,文章,维基等之后,我最终知道了这一点:

1. OSGi框架(在我的例子中是Equinox)可以嵌入到servlet容器中(在我的例子中是Tomcat 7)
2. 或者Tomcat可以嵌入OSGi框架中.

Equinox建议第二种选择更容易.但对于生产他们建议1.我不确定为什么.在哪种情况下真的更好,为什么？

我是一个经验丰富的Tomcat用户,会将Tomcat嵌入Equinox变更管理吗？或者换句话说,嵌入在Equinox中的Tomcat会有什么不同？