小编gex*_*ide的帖子

有可能以某种方式使部分模板规范成为朋友类吗？即你认为你有以下模板类

template <class T> class X{
    T t;
};

现在你有部分特化,例如,指针

template <class T> class X<T*>{
    T* t;
};

我想做到的是,每一个可能X<T*>是朋友类X<S>为ANY S.即X<A*>应该是的朋友X<B>.

当然,我想到了X中通常的模板朋友声明:

template <class T> class X{
    template <class S> friend class X<S*>;
}

但是,这不能编译,g ++告诉我这个:

test4.cpp:34:15:错误:' template<class T> class X'的特化必须出现在命名空间范围内

test4.cpp:34:21:错误:部分特化' X<S*>'声明'朋友'

这根本不可能,还是有一些解决方法？

我之所以要问的是,我需要一个构造函数,X<T*>从任意X<S>(S必须是子类型T)创建这个类.

代码如下所示:

template <class T> class X<T*>{
    T* t;

    template<class S>
    X(X<S> x) : t(&(x.t))  {} //Error, x.t …

我知道多继承的内存布局没有定义,所以我不应该依赖它.但是,我可以在特殊情况下依赖它.也就是说,一个班级只有一个"真正的"超级班级.所有其他都是"空类",即既没有字段也没有虚拟方法的类(即它们只有非虚方法).在这种情况下,这些附加类不应该向类的内存布局添加任何内容.(更简洁地说,在C++ 11中,该类具有标准布局)

我可以推断出所有超类都没有偏移吗？例如:

#include <iostream>

class X{

    int a;
    int b;
};

class I{};

class J{};

class Y : public I, public X,  public J{};

int main(){

    Y* y = new Y();
    X* x = y;
    I* i = y;
    J* j = y;

    std::cout << sizeof(Y) << std::endl 
                  << y << std::endl 
                  << x << std::endl 
                  << i << std::endl 
                  << j << std::endl;
}

这里,Y类X是唯一真正的基类.程序的输出(在linux上用g ++ 4.6编译时)如下:

8

0x233f010

0x233f010

0x233f010

0x233f010 …

考虑我有一个带int...参数的可变参数模板.例如这样的函数:

template<int... t>
int add(){
    return t... + ???
}

所有方法应该做的是添加所有参数.使用递归可变参数模板可以轻松实现.但是,是否也可以使用参数包扩展来表达这种(或者类似于使用其他二元运算符聚合所有模板参数的东西)？

我想将一个以null结尾的字符串复制到另一个位置,并想知道复制的字符串有多长.效率至关重要.有一个strcpy功能可以实现这一点,但它不会返回实际复制的字符数.

当然,我可以通过简单地调用strlen后来检测复制字符串的长度来找到它,但这意味着第二次再次遍历字符串中的字符,尽管strcpy必须跟踪它复制的字符数.出于性能原因,我不想进行这样的第二次遍历.

我知道strcpy使用简单的char-by-char副本编写自己很容易,但我认为标准库可能会应用魔法,这strcpy比使用简单的char-by-char实现更快.

那么,在strcpy没有再次遍历字符串的情况下,获取复制字符数的最佳方法是什么？

我想将 Tableau .hyper 文件转换为 Pandas 数据框。可以将数据帧转换为 .hyper 文件，但不幸的是，我无法想出解决此问题的方法。你怎么能用python实现这一点？

考虑类模板,可以使用类型特征和虚拟启用模板参数为某些类型的组提供模板特化.我早些时候已经问过了.

现在,我对函数模板需要相同的东西:即,我有一个模板函数,并希望对一组类型进行特化,例如,所有类型都是类的子类型X.我可以用这样的类型特征来表达这个:

std::enable_if<std::is_base_of<X, T>::value>::type

我想过这样做:

template <typename T, typename ENABLE = void>
void foo(){
    //Do something
}

template <typename T>
void foo<T,std::enable_if<std::is_base_of<A, T>::value>::type>(){
    //Do something different
}

但是,这不起作用,因为功能模板不允许部分特化.那么怎么做呢？也许类型为trait的默认参数为type？但是代码怎么样呢？

可能重复:
#include <filename>和#include"filename"有什么区别？

编写以下内容时,编译器为什么不抱怨:

#include "stdio.h"

不应该

#include <stdio.h>

相反,因为stdio.h实际上存储在库文件夹中而不是存储在翻译单元的文件夹中？为什么它仍然有效？

我有一个通用类X<T>; 这个类有一个协变部分,我希望能够协同访问.所以我将它分解为一个界面IX<out T>.但是,我希望这个接口只对类本身可见,因为它还包含了方法private.

也就是说,在课堂内部,我可以升级IX<T>并且共同使用它.例如:

class X<T> : IX<T> {

    private interface IX<out T>{ // the private covariant interface
         void foo();
    }

    // It grants access to the private method `foo`
    private T foo(){...}
    public T IX.foo(){ return foo(); }

    private static void someMethod(IX<T> x) {
        // Here I can use `x` covariantly
    }
}

这可能吗？我之前从未听说过private嵌套接口,因为私有接口通常根本没有任何意义.然而,对于泛型,这种接口对于实现"仅私有协方差"是必要的.

当我尝试编译它时,我收到以下错误:

foo.cs(1,14): error CS0246: The type or namespace name `IX' could not be found. Are …

通常的模板结构可以是专门的,例如,

template<typename T>
struct X{};

template<>
struct X<int>{};

C++ 11为我们提供了using表达模板typedef 的新酷语法:

template<typename T>
using YetAnotherVector = std::vector<T>

有没有办法使用类似于结构模板的特化的构造为这些定义模板特化？我尝试了以下方法:

template<>
using YetAnotherVector<int> = AFancyIntVector;

但它产生了编译错误.这有可能吗？

是否有一种方法(例如,定义的常量)来访问编译器在编译的代码中运行的编译标志.

例如,我想要一个程序来编写用于编译它的标志.

int main(){
    std::cout << COMPILE_FLAGS << std::endl;
}

gcc/g ++是否存在这样的常量？甚至更好:是否有在gcc和clang中定义的常量？

我特别感兴趣的是检查优化级别和-march标志的值.那么,如果没有显示所有标志的常量,那么至少有哪些显示这些值？