有没有办法检测用户是否在jQuery中使用移动设备？类似于CSS@media属性？如果浏览器在手持设备上，我希望运行不同的脚本。

jQuery$.browser函数不是我想要的。

我有一个Git存储库，其中包含许多子目录。现在我发现其中一个子目录与另一个子目录无关，应该分离到一个单独的存储库中。

如何在保留子目录中文件的历史记录的同时执行此操作？

我想我可以制作一个克隆并删除每个克隆中不需要的部分，但我想这会在检查旧版本等时提供完整的树。这可能是可以接受的，但我更希望能够假装这两个存储库没有共享的历史。

为了清楚起见，我有以下结构：

XYZ/
    .git/
    XY1/
    ABC/
    XY2/

但我想改为：

XYZ/
    .git/
    XY1/
    XY2/
ABC/
    .git/
    ABC/

我刚听完Scott Meyers关于C++0x的软件工程广播播客采访。大多数新特性对我来说都是有意义的，我现在对C++0x非常兴奋，只有一个例外。我仍然不懂移动语义。。。到底是什么？

我最近切换到将我的存储库同步到GitHub上的https://（由于防火墙问题），它每次都会要求输入密码。

有没有办法缓存凭据，而不是每次git推送时都进行身份验证？

什么是智能指针，什么时候应该使用？

C++11引入了标准化的内存模型，但这到底意味着什么？它将如何影响C++编程？

这篇文章（加文·克拉克引用赫伯·萨特的话）说，

内存模型意味着C++代码现在有一个标准化的图书馆可以调用无论编译器是谁制造的以及在哪个平台上运行。有一种标准的方法来控制不同的线程与处理器的内存。“当你谈论分裂时[代码]跨越不同的核心在标准中，我们谈论的是记忆模型。我们将在不破坏以下假设萨特说。

嗯，我可以在网上记住这段和类似的段落（因为我从出生起就有自己的记忆模型：P），甚至可以发帖回答别人提出的问题，但老实说，我并不完全理解这一点。

C++程序员以前就开发过多线程应用程序，那么，是POSIX线程、Windows线程还是C++11线程又有什么关系呢？有什么好处？我想了解底层细节。

我还感觉到，C++11内存模型与C++11多线程支持有某种关系，正如我经常看到的那样。如果是，具体如何？为什么它们应该是相关的？

我不知道多线程的内部工作原理，也不知道内存模型的一般含义。

如何获取windowWidth、windowHeight、pageWidth、pageHeight、screenWidth、screenHeight、pageX、pageY、screenX、screenY，这些都可以在所有主要浏览器中使用？

假设a1、b1、c1和d1指向堆内存，我的数字代码具有以下核心循环。

const int n = 100000;

for (int j = 0; j < n; j++) {
    a1[j] += b1[j];
    c1[j] += d1[j];
}

该循环通过另一个外部for循环执行10000次。为了加快速度，我将代码更改为：

for (int j = 0; j < n; j++) {
    a1[j] += b1[j];
}

for (int j = 0; j < n; j++) {
    c1[j] += d1[j];
}

在Microsoft Visual C++10.0上编译，经过完全优化，并在Intel Core 2 Duo（x64）上启用了32位SSE2，第一个示例耗时5.5秒，双循环示例仅需1.9秒。

第一个循环的反汇编基本上是这样的（在整个程序中，这个块重复了大约五次）：

movsd       xmm0,mmword ptr [edx+18h]
addsd       xmm0,mmword ptr [ecx+20h]
movsd       mmword ptr [ecx+20h],xmm0
movsd       xmm0,mmword ptr [esi+10h]
addsd       xmm0,mmword ptr [eax+30h]
movsd       mmword ptr [eax+30h],xmm0
movsd       xmm0,mmword ptr [edx+20h]
addsd       xmm0,mmword ptr [ecx+28h]
movsd       mmword ptr [ecx+28h],xmm0
movsd       xmm0,mmword ptr [esi+18h]
addsd       xmm0,mmword ptr [eax+38h]

双循环示例的每个循环都会生成此代码（以下块重复大约三次）：

addsd       xmm0,mmword ptr [eax+28h]
movsd       mmword ptr [eax+28h],xmm0
movsd       xmm0,mmword ptr [ecx+20h]
addsd       xmm0,mmword ptr [eax+30h]
movsd       mmword ptr [eax+30h],xmm0
movsd       xmm0,mmword ptr [ecx+28h]
addsd       xmm0,mmword ptr [eax+38h]
movsd       mmword ptr [eax+38h],xmm0
movsd       xmm0,mmword ptr [ecx+30h]
addsd       xmm0,mmword ptr [eax+40h]
movsd       mmword ptr [eax+40h],xmm0

事实证明，这个问题无关紧要，因为行为严重依赖于数组（n）和CPU缓存的大小。因此，如果有进一步的兴趣，我会重新表述这个问题：

您能否深入了解导致不同缓存行为的细节，如下图中的五个区域所示？通过为这些CPU提供类似的图表，指出CPU/缓存架构之间的差异可能也很有趣。

这是完整的代码。它使用TBB Tick_Count进行更高分辨率的计时，可以通过不定义TBB_timing宏来禁用：

#include <iostream>
#include <iomanip>
#include <cmath>
#include <string>

//#define TBB_TIMING

#ifdef TBB_TIMING   
#include <tbb/tick_count.h>
using tbb::tick_count;
#else
#include <time.h>
#endif

using namespace std;

//#define preallocate_memory new_cont

enum { new_cont, new_sep };

double *a1, *b1, *c1, *d1;


void allo(int cont, int n)
{
    switch(cont) {
      case new_cont:
        a1 = new double[n*4];
        b1 = a1 + n;
        c1 = b1 + n;
        d1 = c1 + n;
        break;
      case new_sep:
        a1 = new double[n];
        b1 = new double[n];
        c1 = new double[n];
        d1 = new double[n];
        break;
    }

    for (int i = 0; i < n; i++) {
        a1[i] = 1.0;
        d1[i] = 1.0;
        c1[i] = 1.0;
        b1[i] = 1.0;
    }
}

void ff(int cont)
{
    switch(cont){
      case new_sep:
        delete[] b1;
        delete[] c1;
        delete[] d1;
      case new_cont:
        delete[] a1;
    }
}

double plain(int n, int m, int cont, int loops)
{
#ifndef preallocate_memory
    allo(cont,n);
#endif

#ifdef TBB_TIMING   
    tick_count t0 = tick_count::now();
#else
    clock_t start = clock();
#endif
        
    if (loops == 1) {
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++){
                a1[j] += b1[j];
                c1[j] += d1[j];
            }
        }
    } else {
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                a1[j] += b1[j];
            }
            for (int j = 0; j < n; j++) {
                c1[j] += d1[j];
            }
        }
    }
    double ret;

#ifdef TBB_TIMING   
    tick_count t1 = tick_count::now();
    ret = 2.0*double(n)*double(m)/(t1-t0).seconds();
#else
    clock_t end = clock();
    ret = 2.0*double(n)*double(m)/(double)(end - start) *double(CLOCKS_PER_SEC);
#endif
    
#ifndef preallocate_memory
    ff(cont);
#endif

    return ret;
}


void main()
{   
    freopen("C:\\test.csv", "w", stdout);

    char *s = " ";

    string na[2] ={"new_cont", "new_sep"};

    cout << "n";

    for (int j = 0; j < 2; j++)
        for (int i = 1; i <= 2; i++)
#ifdef preallocate_memory
            cout << s << i << "_loops_" << na[preallocate_memory];
#else
            cout << s << i << "_loops_" << na[j];
#endif
            
    cout << endl;

    long long nmax = 1000000;

#ifdef preallocate_memory
    allo(preallocate_memory, nmax);
#endif
    
    for (long long n = 1L; n < nmax; n = max(n+1, long long(n*1.2)))
    {
        const long long m = 10000000/n;
        cout << n;

        for (int j = 0; j < 2; j++)
            for (int i = 1; i <= 2; i++)
                cout << s << plain(n, m, j, i);
        cout << endl;
    }
}

它显示了n的不同值的FLOP/s。

@Component、@Repository和@Service注释是否可以在Spring中互换使用，或者它们除了充当符号设备之外，是否提供任何特定功能？

换句话说，如果我有一个Service类，并且我将注释从@Service更改为@Component，它的行为是否仍然相同？

或者注释是否也会影响类的行为和功能？

我正在开发一个web应用程序，我希望内容能够填满整个屏幕的高度。

该页面有一个标题，其中包含徽标和帐户信息。这可以是任意高度。我希望contentdiv将页面的其余部分填充到底。

我有一个header div和一个content div。目前，我正在为布局使用一个表，如下所示：

CSS和HTML

#第页{高度：100%；宽度：100%}#td含量{高度：100%；}#内容{溢出：自动；/*或溢出：隐藏*/}<table id=“page”><tr><td id=“tdheader”><div id=“header”></分区></td></tr><tr><td id=“tdcontent”><div id=“content”></分区></td></tr></table>

页面的整个高度已填充，不需要滚动。

对于contentdiv中的任何内容，设置top:0；会把它放在标题下面。有时内容将是一个真实的表格，其高度设置为100%。将标题放在内容内不允许这样做。

有没有一种方法不使用桌子就能达到同样的效果？

更新：

contentdiv中的元素也将高度设置为百分比。因此，div中100%的内容将填充到底部。50%的两个元素也是如此。

更新2:

例如，如果标题占屏幕高度的20%，则在#内容内部指定50%的表将占屏幕空间的40%。到目前为止，把整个东西包在桌子里是唯一有效的方法。