小编tly*_*tly的帖子

我正在尝试创建一个operator<<for std::ostream和任何Iterable类型.

这是代码:

template <class T,template<class> class Iterable> inline std::ostream& operator<<(std::ostream& s,const Iterable<T>& iter){
    s << "[ ";
    bool first=false;
    for(T& e : iter){
        if(first){
            first=false;
            s << e;
        }else{
            s << ", " << e;
        }
    }
    s << " ]";
    return s;
}

不幸的是,找不到我的运算符作为a的匹配项,vector<uint>并且编译器尝试匹配operator<<(basic_ostream<_CharT, _Traits>&& __os, const _Tp& __x).

知道我怎么能改变过载被识别？

考虑以下用于向量和矩阵乘法的代码片段:

#include <array>

template<typename T,size_t N> using vec = std::array<T,N>;

template<typename T,size_t N,size_t M> using mat = vec<vec<T,M>,N>;

template<typename T,typename U,size_t N> 
vec<T,N> operator*(const vec<T,N>& a,const vec<U,N>& b){
    return {}; //implement componentwise mult.
}

template<typename T,typename U,size_t N,size_t M,size_t L>
mat<T,L,M> operator*(const mat<T,N,M>& a,const mat<U,L,N>& b){
    return {}; //implement matrix mult.
}

int main(){
    mat<float,4,4> a,b;
    auto c = a * b;
}

我定义了2个operator*重载,其中第二个重载明确使用矩阵.

这将导致"模糊过载"错误GCC 5.2,但在我看来,第二次过载比第一次过载更专业.

我现在替换第二个重载中的typedef:

mat<T,L,M> operator*(const mat<T,N,M>& a,const mat<U,L,N>& b)

变为:

mat<T,L,M> operator*(const …

在c ++中norm,复数数字c的定义为abs(c)^2.这意味着它re(c)^2+im(z)^2.

这是实施:

template<bool>
struct _Norm_helper
{
  template<typename _Tp>
    static inline _Tp _S_do_it(const complex<_Tp>& __z)
    {
      const _Tp __x = __z.real();
      const _Tp __y = __z.imag();
      return __x * __x + __y * __y;
    }
};

template<>
struct _Norm_helper<true>
{
  template<typename _Tp>
    static inline _Tp _S_do_it(const complex<_Tp>& __z)
    {
      _Tp __res = std::abs(__z);
      return __res * __res;
    }
};

为什么有人想要使用第二个实现？

第一个显然更快,因为它不使用abs,sqrt涉及的地方.

在使用SFINAE编写模板专业化时,您经常会因为一个小的不存在的成员或函数而需要编写一个全新的特化.我想把这个选择打包成一个小的声明,比如orElse<T a,T b>.

小例子:

template<typename T> int get(T& v){
    return orElse<v.get(),0>();
}

这可能吗？

该GtkOverlay小部件有一个特殊的set_overlay_pass_through方法将输入传递到底层覆盖层。我想使用此功能GtkDrawingArea在 UI 上叠加来添加绘图。不幸的是，它对我不起作用，没有输入事件被传递。

我正在使用msys2和gtkmm。

这是我的代码：

Gtk::DrawingArea drawingArea;
Gtk::Fixed nodeBox; //filled with several widgets
Gtk::Overlay overlay;
overlay.add_overlay(nodeBox);
overlay.add_overlay(drawingArea);
overlay.set_overlay_pass_through(drawingArea,true);
window.add(overlay);

当我更改两个add_overlay调用的顺序时，输入事件正常工作，但nodeBox隐藏绘图区域的小部件。

我试图用 a 连接两个节点CubicCurve，并希望跟踪节点中的变化以将曲线移动到正确的位置。它看起来像这样：

这些TitledPane是可拖动的，所以我需要监听节点的位置变化。由于曲线连接到这些蓝色和绿色按钮，因此当父级移动时，按钮的layoutX或属性不会改变。layoutY

我的问题：是否有一种通用方法来监听节点的位置变化，或者我应该编写一个在TitledPane移动时调用的自定义监听器？

我正在尝试创建一种直接扩展多个参数包的方法.我创建了一个函数template<size_t X,typename F> auto sequenceFunc(F&& f),f用扩展函数调用给定的函数integer_sequence.

这适用于这样的小功能:

template<typename T,
         size_t A,size_t B>
vec<B,T> col(const mat<A,B,T>& a,const size_t& i){
    return sequenceFunc<A>([&](auto... J) -> vec<B,T>{
        return { a[J][i]... }; //expands to a[0][i], a[1][i], ... a[A-1][i]
    });
}

遗憾的是,即使遵循规则,我也无法扩展多个参数包,只有一个参数包可以在...-expression中.这是我尝试使用此函数进行矩阵乘法:

template<typename S,typename T,
         size_t A,size_t B,size_t C>
mat<C,B,S> mul(const mat<A,B,S>& a,const mat<C,A,T>& b){
    return sequenceFunc<B>([&](auto... I)->mat<C,B,S>{ //for all B rows in a...
        return {
            sequenceFunc<C>([&](auto... J)->vec<C,S>{ // ... look at all C columns in b and …

我想为a创建一个模板,std::function<T(Variable nums of arguments)>通过调用默认构造函数来返回类的默认值.

我试过这个:

template <class T,class... Args> inline std::function<T(Args...)> zero(){
    return [](Args...){ return T();};
}

我想在你只需要默认值而没有复杂功能的情况下使用它,例如在我的Image<T>类中:

template <typename T> class Image{
    ...
    void drawEachPixel(std::function<T(size_t,size_t)> func){
        forRange(x,w){
            forRange(y,h){
                this->setPixel(x,y,func(x,y));
            }
        }
    }
    ...
};

清除我可以打电话的图像:

image.drawEachPixel(zero());

编译时我得到错误no matching function for call to 'Image<unsigned char>::drawEachPixel(std::function<unsigned char()>)'...

我想在 Windows 上调整内存映射文件的大小，而不会使从先前调用MapViewOfFileEx. 这样，指向整个应用程序中存储的任何文件数据的所有指针都不会因调整大小操作而失效。

我找到了问题的解决方案，但我不确定这种方法是否真的能保证在所有情况下都有效。

这是我的方法：我保留一个大的内存区域VirtualAlloc：

reserved_pages_ptr = (char*)VirtualAlloc(nullptr, MAX_FILE_SIZE, MEM_RESERVE, PAGE_NOACCESS);
base_address = reserved_pages_ptr;

每次调整内存映射大小时，我都会关闭旧的文件映射，释放保留的页面并保留当前文件大小不需要的其余页面：

filemapping_handle = CreateFileMappingW(...);

SYSTEM_INFO info;
GetSystemInfo(&info);
const DWORD page_size = info.dwAllocationGranularity;

const DWORD pages_needed = file_size / page_size + size_t(file_size % page_size != 0);

// release reserved pages:
VirtualFree(reserved_pages_ptr, 0, MEM_RELEASE);
// reserve rest pages:
reserved_pages_ptr = (char*)VirtualAlloc(
    base_address + pages_needed * page_size, 
    MAX_FILE_SIZE - pages_needed * page_size, 
    MEM_RESERVE, PAGE_NOACCESS
);

if(reserved_pages_ptr != base_address + pages_needed * page_size)
{
    //I …

我最近遇到了强制转换和多重继承的问题:我需要转换为Base*to Unrelated*,因为特定的Derived类派生了Unrelated类.

这是一个简短的例子:

#include <iostream>

struct Base{
    virtual ~Base() = default; 
};

struct Unrelated{
    float test = 111;    
};

struct Derived : Base,Unrelated{};

int main(){
    Base* b = new Derived;
    Unrelated* u1 = (Unrelated*)b;
    std::cout << u1->test << std::endl; //outputs garbage
    Unrelated* y = dynamic_cast<Unrelated*>(b);
    std::cout << y->test << std::endl; //outputs 111
}

第一个演员显然不起作用,但第二个演员确实有效.我的问题是:为什么第二次演员工作？难道dynamic_cast只适合投射到相关的类类型吗？我认为Unrelated在运行时没有任何关于它的信息,因为它不是多态的.

编辑:我使用colirus gcc作为示例.