问题列表 - 第31233页

可能是一个非常模糊和广泛的问题,但是所有C++编译器在将代码编译成机器代码之前是否先将代码编译成C？

我使用两个显示器,并经常使用两个框架打开的emacs; 每个监视器一个.每个框架被分成两个并排的窗口,如下所示:

 a | b   <-- frame 1 in monitor 1
-------
 c | d   <-- frame 2 in monitor 2

当我在窗口a中点击"编译"按钮时,编译缓冲区在其旁边的缓冲区中打开.到现在为止还挺好:

 a | compilation
-----------------
 c |     d

但是,如果我然后移动到窗口c来编辑一些东西,然后再次点击编译,窗口d也会访问编译缓冲区:

 a | compilation
------------------
 c | compilation

所以现在我有一半的屏幕空间占用了同一个编译缓冲区的两个副本,想知道为什么我有两个显示器:)

当我的光标位于当前打开的编译缓冲区旁边的缓冲区中时,我可以通过认真地仅仅点击编译键来防止这种情况,但是我很早就打了'编译',而且我经常没有心思这样做.我觉得必须有一些我可以调整的东西.emacs所以我不应该这样做.

有什么建议？理想情况下,当我点击'compile'时,当前打开的编译缓冲区应该从之前的窗口移动到当前使用的窗口旁边的窗口.如果这太复杂了,我很容易解决让emacs 没有访问相邻窗口中的编译缓冲区,如果它已经在另一个窗口中打开了.

Joshua Bloch的"Effective Java",第51项不是依赖于线程调度程序,也不是在可运行状态下不必要地保留线程.引用文字:

保持可运行线程数量的主要技术是让每个线程执行少量工作,然后使用Object.wait等待某些条件或使用Thread.sleep等待一段时间.线程不应该忙等待,反复检查数据结构等待发生的事情.除了使程序容易受到调度程序的变幻莫测之外,忙等待还可以大大增加处理器的负载,减少其他进程在同一台机器上可以完成的有用工作量.

然后继续显示忙碌等待的微基准测试与正确使用信号.在书中,忙碌等待执行17次往返/秒,而等待/通知版本每秒执行23,000次往返.

但是,当我在JDK 1.6上尝试相同的基准测试时,我看到恰恰相反 - 忙等待是760K往返/秒,而等待/通知版本是53.3K往返/秒 - 也就是说,等待/通知应该是~1400时间更快,但结果慢了约13倍？

我知道繁忙的等待并不好,信号仍然更好 - 忙等待版本的CPU利用率约为50%,而等待/通知版本的停留率约为30% - 但有没有解释数字的东西？

如果它有帮助,我在Win 7 x64(核心i5)上运行JDK1.6(32位).

更新:来源如下.要运行繁忙的工作台,请将PingPongQueue的基类更改为BusyWorkQueue import java.util.LinkedList; import java.util.List;

abstract class SignalWorkQueue { 
    private final List queue = new LinkedList(); 
    private boolean stopped = false; 

    protected SignalWorkQueue() { new WorkerThread().start(); } 

    public final void enqueue(Object workItem) { 
        synchronized (queue) { 
            queue.add(workItem); 
            queue.notify(); 
        } 
    } 

    public final void stop()  { 
        synchronized (queue) { 
            stopped = true; 
            queue.notify(); 
        } 
    } 
    protected abstract void processItem(Object workItem) 
        throws …

我想尝试匹配输入

<foo>
<bar>
#####<foo>
#####<bar>

我试过#{5}?<\w+>,但它不匹配<foo>和<bar>.

这种模式有什么问题,如何修复？

大胆的大写锁定TL; DR:

我知道选择器的具体情况如何确定,我认为它使用了飞溅的假设,我可以用有效的理论关系来支持我的不满,请不要回答解释W3计算规则的具体情况,请仔细阅读问题 < - 阅读.

这让我困扰了一段时间,当我为某些HTML编写一个类似于下面的样式时:

...
<div id="outer">
    <span id="inner"></span>
    <span></span>
    ...
</div>
...

为什么特异性规则会使选择器"#outer span"比"#inner"更具体？ID是唯一的,所以当我说"#inner"时,我只能指一个元素,为什么它不那么具体？我理解确定特异性的规则,我只是想知道这是故意的还是偶然的,如果有人知道如何向编写css标准的人提出这个问题.

我应该注意,我确实理解我可以使用#outer #inner来确保最大的特异性,但这似乎首先打败了ID的目的.当我编写模板时,这也是一个有问题的解决方案,我不确定一个ID是否会在另一个内部.我不是在找一个解决方法,只是一个理论答案.

我的问题是理论,完全基于集合逻辑.虽然我有,如果你为n个可能的项目中的1项定义一个规则,那么具体到你能去的那个吗？为什么CSS选择器的创建者会制定一个规则,可以定义n个可能项目的m个项目,其中m是n的子集,作为更具体的规则？

我的想法是#id将等同于按名称识别1个项目,而#id elm将根据名称与项目的关系来识别组.调用命名项比具有命名关系的未命名组更具特异性是完全违反直觉的.

我正在创建一个使用ASP.net MVC 2.0的网站,该网站使用两种不同的语言(英语和波斯语).我希望这些语言有两种不同的布局,英语从左到右,波斯语从右到左布局.

我想到的是,如果我可以有两个不同的css文件,比如当你用字符串或图像本地化来完成网站的工作时,问题是我需要知道如何做到这一点!

关于如何执行此操作的任何其他建议将是有帮助的.

什么是依赖范围以及在以下错误的上下文中typename的含义是什么？

$ make
g++ -std=gnu++0x main.cpp
main.cpp:18:10: error: need 'typename' before 'ptrModel<std::vector<Data> >::Type' because 'ptrModel<std::vector<Data> >' is a dependent scope
make: *** [all] Error 1


/*
 * main.cpp
 */

#include <vector>
#include <memory>

template<typename T>
struct ptrModel
{
 typedef std::unique_ptr<T> Type;
};


template<typename Data>
struct ptrType
{
 typedef ptrModel< std::vector<Data> >::Type Type;
};

int main()
{
 return 0;
}

在我看来,如果你有一些像这样的C++代码:

int f()
{
  try {
    if( do_it() != success ) {
      throw do_it_failure();
    }
  } catch( const std::exception &e ) {
    show_error( e.what() );
  }
}

C++编译器应该能够优化throw并捕获几乎简单的goto.

但是,从我查看反汇编和单步执行代码的经验来看,编译器总是跳过非常混乱的异常处理库.

他们为什么这样做？是否存在一些阻止优化的语言要求？如果它是:

int f()
{
  try { throw std::runtime_error("Boo!"); }
  catch ( const std::exception &e ) { std::cout << e.what() << std::endl; }
}

为什么编译器不只是重写为

int f()
{
  std::cout << "Boo!" << std::endl;
}

使用 Robocopy 从一个来源复制到多个目的地是否可能且安全？

我的意思是，在 bat 文件中是这样的：

ROBOCOPY source dest_1
ROBOCOPY source dest_2

有什么副作用吗？

谢谢！

我试图在我的代码中读取系统日志以生成类似错误报告的内容.与adb logcat类似,但是采用编程方式.

我怎样才能做到这一点？