小编djf*_*djf的帖子

我的MySQL数据库包含几个使用不同存储引擎的表(特别是myisam和innodb).如何找出哪个表使用哪个引擎？

我刚刚在64位fedora 14的全新安装上安装了eclipse,android sdk和jdk,但是当我创建一个新项目时,我在控制台中收到以下错误:

android-sdks/build-tools/17.0.0/aapt:加载共享库时出错:libz.so.1:无法打开共享对象文件:没有这样的文件或目录

我使用64位机器,我需要安装一些32位驱动程序,所以我想安装:

sudo apt-get install ia32-libs读取包列表...完成构建依赖树...完成E:找不到包ia32-libs

任何人都帮我解决64bit fedora 14机器libz.so.1问题

我正在考虑在我们目前使用的现有专有第三方网络协议之上编写自定义Asio服务.

根据Highscore Asio指南,您需要实现三个类来创建自定义Asio服务:

• 从boost::asio::basic_io_object表示新I/O对象派生的类.
• 从boost::asio::io_service::service表示向I/O服务注册并可从I/O对象访问的服务派生的类.
• 不是从表示服务实现的任何其他类派生的类.

网络协议实现已经提供了异步操作并且具有(阻塞)事件循环.所以我想,我会把它放到我的服务实现类中,并在内部工作线程中运行事件循环.到现在为止还挺好.

看一下自定义服务的一些例子,我注意到服务类产生了自己的内部线程(实际上它们实例化了自己的内部io_service实例).例如:

1. Highscore页面提供了一个目录监视器示例.它本质上是inotify的包装器.有趣的课程是inotify/basic_dir_monitor_service.hpp和inotify/dir_monitor_impl.hpp.Dir_monitor_impl处理与inofity的实际交互,这是阻塞,因此在后台线程中运行.我同意这一点.但是它basic_dir_monitor_service也有一个内部工作线程,所有似乎正在做的就是在主要io_service和主要之间移动请求dir_monitor_impl.我玩了代码,删除了工作线程,basic_dir_monitor_service然后将请求直接发送到主io_service,程序仍像以前一样运行.

2. 在Asio的自定义记录器服务示例中,我注意到了相同的方法.该logger_service产卵内部工作线程来处理日志请求.我没有时间玩这个代码,但我认为,应该可以将这些请求直接发布到主io_service.

拥有这些"中间工作者"有什么好处？难道你不能一直将所有工作发布到主io_service吗？我是否错过了Proactor模式的一些关键方面？

我应该提一下,我正在为功能不足的单核嵌入式系统编写软件.将这些额外的线程放在适当的位置似乎会强加不必要的上下文切换,如果可能的话我想避免这种切换.

今天我偶然发现了以下问题.有人太喜欢大括号初始化器并且不小心试图实例化接口类.忍受我:

#include <iostream>

class IFoo
{
public:
   virtual ~IFoo() = default;
   virtual bool getFoo() const = 0;
};

void processFoo(const IFoo &fooImpl)
{
    bool foo = fooImpl.getFoo();
    std::cout << "got foo " << foo << std::endl;
}

int main()
{
   processFoo({});  // <- why is this valid?!
   return 0;
}

到目前为止,我一直期望编译器会发出类似于在尝试调用IFoo()或调用某些东西时所获得的错误IFoo{}.但是,上面的代码在没有警告的情况下进行编译(在gcc 6.2上),但是当你尝试调用该方法时,很明显会以" 纯虚方法调用 " 结束getFoo().实例.

有人可以向我解释那里发生了什么事吗？

假设我有2个Protobuf-Messages,A和B.它们的整体结构相似,但不完全相同.所以我们将共享的东西移到一个我们称为Common的单独消息中.这很好用.

但是,我现在面临以下问题:我需要处理序列化消息的特殊情况,但我不知道它是A类型还是B类消息.我有一个C++工作解决方案(显示下面),但我没能找到在Python中做同样事情的方法.

例:

// file: Common.proto
// contains some kind of shared struct that is used by all messages:
message Common {
 ...
}

// file: A.proto
import "Common.proto";

message A {
   required int32  FormatVersion             = 1;
   optional bool   SomeFlag [default = true] = 2;
   optional Common CommonSettings            = 3;

   ... A-specific Fields ...
}

// file: B.proto
import "Common.proto";

message B {
   required int32  FormatVersion             = 1;
   optional bool   SomeFlag [default = true] = 2;
   optional Common CommonSettings            = …

今天我偶然发现了一个像这样的代码片段:

class A 
{
    A() = default;
    A (const A&) = delete; 

    ...
}

我从未见过delete或default关键字.它们是C++ 11标准的一部分吗？它们用于什么？

我写了一个java类:

public class Tuple<X, Y> { 
  public final X x; 
  public final Y y; 
  public Tuple(X x, Y y) { 
    this.x = x; 
    this.y = y; 
  } 
}

但是当我创建这样的函数时:

public Tuple<boolean, String> getResult()
{
    try {
        if(something.equals(something2))
             return new Tuple(true, null);
    }
    catch (Exception e){
        return new Tuple(false, e.getMessage());
}

但是,我收到以下编译错误:

unexpected type
  required: reference
  found:    boolean

我可以做什么？

我想知道是否有更好的方法将一个类的Boost信号直接连接到另一个类的信号？

例如,想象一个具有一堆成员的外观类,它们提供自己的信号.现在假设立面想暴露这些信号.我通常最终编写样板方法,然后将其作为信号处理程序连接.

using namespace boost::signal;

class A
{
public:
  A(){};
  virtual ~A(){};

  signal<void()> signalA;
};

class B
{
public:
  B(){};
  virtual ~B(){};

  signal<void()> signalB;
};

class Facade
{
private:
  A& a;
  B& b;

public:
  Facade(A& refA, B& refB) 
  : a(refA), b(refB) 
  {
    // connect A's signal to facadeSignalA
    a.signalA.connect(boost::bind(&Facade::forwardedSignalA, this));
    // connect B's signal to facadeSignalB
    b.signalB.connect(boost::bind(&Facade::forwardedSignalB, this));
  }
  virtual ~Facade() {};

  // user visible signals
  signal<void()> facadeSignalA;
  signal<void()> facadeSignalB;

private:
  // ugly boilerplate code used to forward …

Common Lisp支持过多的格式化指令.但是,我找不到一个方便的指示我的问题.基本上,我想打印一个数字网格.

使用列表,以下工作很好:

(format t "~{~A|~A|~A~%~^-----~%~}" '(1 2 3 4 5 6 7 8 9))

1|2|3
-----
4|5|6
-----
7|8|9
NIL

我无法找到类似的构造来迭代向量.CLtL2明确指出 ~{...~}要将列表作为参数.无论如何我尝试使用矢量,但是我的Clisp正确地说出了错误的参数类型.作为一种解决方法,我使用全能将我的矢量转换为一个扔掉的列表loop.

(let ((lst (loop for e across '#(1 2 3 4 5 6 7 8 9) collecting e)))
   (format t "~{~A|~A|~A~%~^-----~%~}" lst))

1|2|3
-----
4|5|6
-----
7|8|9
NIL

这是有效的,但它让我感到笨拙的临时解决方案.我宁愿不为此创建大量的临时列表format.有没有办法直接迭代向量？

出于好奇,有没有理由format不支持序列？

作为Java代码的一部分,明天需要在JUnit中完成一些任务.

例如,有3个任务:

• task1 - 完成
• task2 - 明天再做
• task3 - 然后就会发生这种情况

因此,根据要求,我需要在Java中将今天的日期设置为明天.