小编Gun*_*iez的帖子

    template<int x> struct A {                                                                                                    
        template<int y> struct B {};.                                                                                             
        template<int y, int unused> struct C {};                                                                                  
    };                                                                                                                            

    template<int x> template<> 
    struct A<x>::B<x> {}; // error: enclosing class templates are not explicitly specialized

    template<int x> template<int unused> 
    struct A<x>::C<x, unused> {}; // ok

那么,如果外部类也不是专用的,为什么不允许内部嵌套类(或函数)的显式特化？奇怪的是,如果我只是简单地添加一个虚拟模板参数来部分地专门化内部类,我可以解决这个问题.使事情更丑陋,更复杂,但它确实有效.

我会将完全特化视为部分特化的子集 - 特别是因为您可以通过添加伪参数将每个完整的特化表示为部分.因此,部分和完全专业化之间的消歧对我来说并没有多大意义.

不幸的是,没有人在comp.std.c ++敢于回答,所以我再次以赏金把它放在这里.

注意:我需要此功能用于一组外部类的内部类的递归模板,而内部参数的特化确实取决于外部模板参数.

我需要在子文件夹中为我的应用程序放置DLL.可以通过app.config设置此子文件夹:

  <runtime>
    <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
      <probing privatePath="Libs"/>
    </assemblyBinding>
  </runtime>

但由于某些原因,我不想在这种情况下使用.config文件.是否可以直接从应用程序代码设置探测路径？我确信DLL总是在这个文件夹中.

有任何想法吗？

我需要存储大约-10000到10000范围内的值.在范围边界,所需的精度不是很高(可能大约64,我会看到它是如何拟合的),大约为零,精度需要为1或更好.

不幸的是,空间非常有限,不超过12位,甚至更好.所以严格来说,甚至半浮标都出来了.是否有一个开源库,它处理一些非常短的浮点格式,短尾数和指数长度？像8位尾数和3位指数.

只需要从/到更大格式的转换,不进行算术运算.

我有一个包含多个c#类库的ac#解决方案.我最近正在做一些研究,建议我的库中输出的程序集应该签名,并使用强名称签名.首先,我想知道我是否最好进步？从这些类库输出的库用于多个其他项目.

如果从我之前的问题建议我是的,我应该签署我的dll,我使用的.snk,这可以用于解决方案中的每个类库吗？或者每个类库必须是一键吗？

我认为问题很常见.您有一些输入字符串,并且必须根据字符串的内容调用函数.类似于字符串的switch().考虑命令行选项.

目前我正在使用:

using std::string;

void Myclass::dispatch(string cmd, string args) {
    if (cmd == "foo")
        cmd_foo(args);
    else if (cmd == "bar")
        cmd_bar(args);
    else if ...
        ...
    else
       cmd_default(args);
}

void Myclass::cmd_foo(string args) {
...
}

void Myclass::cmd_bar(string args) {
...
}

并在标题中

class Myclass {
    void cmd_bar(string args);
    void cmd_foo(string args);
}

所以每个foo和bar我都要重复四次(4次).我知道我可以先将函数指针和字符串提供给静态数组,然后在循环中进行调度,保存一些if ... else行.但是有一些宏技巧(或预处理器滥用,取决于POV),这使得有可能以某种方式定义函数,同时让它自动更新数组？所以我只需要写两次,如果内联使用,可能只写一次？

我正在寻找C或C++的解决方案.

如果我定义一个自己的赋值运算符,它的签名与通常生成的默认赋值运算符不同:

struct B;
struct A {
void operator = (const B& b) {
    // assign something
}
};

默认赋值运算符,在这种情况下operator = (A&)(或类似的,如果错误,纠正我)变得未定义/不可访问？

如果我们定义了一些其他构造函数,那么AFAIK对于默认构造函数是正确的,它不存在.但我真的不确定其他"神奇"默认情况是否属于这种情况.

我问的原因是:我想避免通过隐式类型转换意外调用默认的复制构造函数.如果它不存在,它永远不会发生.

请考虑以下代码:

#include <iostream>

template<typename T>
void f(T x) {
    std::cout << sizeof(T) << '\n';
}

int main()
{
    int array[27];
    f(array);
    f<decltype(array)>(array);
}

编者注:使用的原始代码typeof(array),但这是一个GCC扩展.

这将打印

8 (or 4)
108

在第一种情况下,数组显然衰减到指针而T变为int*.在第二种情况下,T被迫int[27].是否定义了衰变/替代实施的顺序？是否有更优雅的方式强制类型int[27]？除了使用std :: vector？

我正在研究一个项目,我需要根据图像的行和列来计算某些东西.获取图像行的位很容易.但是,为了获取每列的位,我需要转置图像,使列成为行.

我正在使用BMP图片作为输入.BMP图片中有多少行X列？如果可能的话,我想看一个伪代码或其他东西.

我有一些来自硬件的数据.数据以32字节为单位,可能有数百万个块.数据块按以下方式分散在两半中(字母是一个块):

A C E G I K M O B D F H J L N P

或者如果编号

0 2 4 6 8 10 12 14 1 3 5 7 9 11 13 15

首先是所有具有偶数索引的块,然后是奇数块.是否有专门的算法来正确地重新排序数据(字母顺序)？

限制主要是空间.我不想再分配另一个缓冲区来重新排序:再多一个块.但我还想保持低移动次数:一个简单的快速排序就是O(NlogN).对于这种特殊的重新排序情况,O(N)中是否有更快的解决方案？

这是一个学术观点,但我觉得如果我不理解为什么这会被诸如Effective Java和许多SO问题这样的书推荐,我不完全理解哈希码.

假设:

public sealed class Point
{
    private readonly int x;
    private readonly int y;

    //constructor ommited

    //equals ommited

    public override int GetHashcode()
    {
       int hash = 17; //why should the initial value be non-zero?
       unchecked
       {
         hash = hash * 31 + x; //do not tell me why I should use primes - that is not the question
         hash = hash * 31 + y;
         return hash;
       }
    }
}

现在,据推测,初始值的原因是它减少了其中一个组件为零的冲突.

我很想找到任何有帮助的例子.

这是一个碰撞的例子,但是初始值没有任何可能性.

x   y   Hash Without initial …