LmTinyToon's questions

为什么复制构造函数的两个版本在使用时会给出不同的结果enable_if？据我了解，使用的两个复制构造函数应该产生相同的结果（仅用于未定义Settings<int>）

template <typename Type>
struct Predicate : std::integral_constant<bool, true>
{
};
template <>
struct Predicate<int> : std::integral_constant<bool, false>
{
};

template <typename FooType>
struct Settings
{
    Settings() {}

    //  Here it works fine
    template <typename OtherFooType>
    Settings(const Settings<OtherFooType>& other, std::enable_if_t<Predicate<OtherFooType>::value, int*> = 0) {}

    //  In this case enable_if does not work
    //template <typename OtherFooType>
    //Settings(typename std::enable_if<Predicate<OtherFooType>::value, const Settings<OtherFooType>&>::type other){}
};

int main()
{
    Settings<float> f = Settings<char>();
    return 0;
}

我正在探索图形库的可能性WinUi 3。我对改变小部件（控件，换句话说就是视图）显示的能力特别感兴趣。但是在浏览了文档后，我很惊讶我无法快速找到对小部件自定义渲染的支持。我什至查看了反汇编的库（实现Control、FrameworkElement等Button）——我在任何地方都没有看到绘图方法。渲染模型不清楚，库如何绘制控件以及如何自己覆盖渲染？

在我的理解中，iso 文件是光盘的映像。即，磁盘内容的“原始”未压缩副本，其中包含某些文件系统（例如 UDF）的快照。因此，我对以下问题感兴趣，iso文件是否仅用于存储光盘的内容？那么，例如，为什么 ubuntu 操作系统是以 iso 格式存储的呢？为什么不使用不同的格式来存储 zip 类型？毕竟系统经常是通过usb启动的（然后就不再需要光盘的结构了）？

假设我想实现对我的协议的支持foo，这样当foo://blablabla在浏览器中打开资源时，我的程序将被调用foo.exe参数foo://blablabla。这种支持应该适用于 Windows 7、8、10。对于 Windows 7，这很简单 - 只需在注册表中添加一个条目，例如：

HKEY_CLASSES_ROOT
myscheme
(Default) = "URL:Foo Protocol"
URL Protocol = ""
DefaultIcon
   (Default) = "foo.exe,1"
shell
   open
      command
           (Default) = "C:\Program Files\Foo\foo.exe" "%1"

但！带有此 API 的页面 ( https://msdn.microsoft.com/en-us/windows/desktop/aa767914 ) 已被标记为已过时（推荐的版本相对而言无处可寻 - 好吧，至少我没有找到任何东西在推荐的链接上）。据我了解，这种方法不能在较新的版本下使用（顺便说一下，它可以在 Windows 10 下使用——我不知道为什么）。我开始研究 Windows 8 的这个问题（https://docs.microsoft.com/ru-ru/windows/desktop/w8cookbook/file-type-and-protocol-associations-model），它说现在程序不能正确建立你的协会——但这怎么可能呢？因为上面的例子对我有用。

这是文档中的引用

Windows 8 中的文件类型和 URI 关联模型已更改。应用程序不再能够以编程方式将自己设置为文件类型或 URI 的默认处理程序。相反，现在用户始终控制文件类型或 URI 方案的默认处理程序。

据我了解，windows 10也不应该支持这样的关联设置？这三个版本的windows下怎么可能实现对这些协议的支持呢？老实说，我对文档一无所知。我只是模糊地想象，现在用户自己必须管理这些关联？这是Windows 8的简短摘录

如果您希望允许您的应用程序的用户访问默认管理 UI（不再支持应用程序内的管理 UI），请与“设置默认程序”控制面板集成

调用 IApplicationAssociationRegistrationUI::LaunchAdvancedAssociationUI 允许用户访问指定应用程序的“设置默认程序”控制面板页面

我正在尝试动态生成以下通用函数：

MyList<T> CreateList<T>(T arg) => new MyList<T>(){arg};

下面是对文档稍作修改的程序（原始程序在这里https://docs.microsoft.com/en-us/dotnet/framework/reflection-and-codedom/how-to-define-a-generic-带反射发射的方法）。对我来说，关键点是调用Add类中实现的方法List。我使用以下方法得到它TypeBuilder.GetMethod：

public class MyList<T> : List<T>
{
}
public static void Main()
{
    var asmName = new AssemblyName("DemoMethodBuilder1");
    var demoAssembly = AppDomain.CurrentDomain.DefineDynamicAssembly(asmName, AssemblyBuilderAccess.RunAndSave);

    var demoModule = demoAssembly.DefineDynamicModule(asmName.Name, asmName.Name + ".dll");
    var demoType = demoModule.DefineType("DemoType", TypeAttributes.Public);

    var create_list_method = demoType.DefineMethod("CreateList", MethodAttributes.Public | MethodAttributes.Static);

    var TInput = create_list_method.DefineGenericParameters(new string[] { "TInput" })[0];
    var t_list_type = typeof(MyList<>).MakeGenericType(TInput);

    create_list_method.SetParameters(new Type[] { TInput });
    create_list_method.SetReturnType(t_list_type);

    var ilgen = create_list_method.GetILGenerator();

    ilgen.Emit(OpCodes.Newobj, TypeBuilder.GetConstructor(t_list_type, typeof(MyList<>).GetConstructors()[0]));
    ilgen.Emit(OpCodes.Dup);
    ilgen.Emit(OpCodes.Ldarg_0);
    ilgen.Emit(OpCodes.Callvirt, TypeBuilder.GetMethod(t_list_type, typeof(MyList<>).GetMethod("Add")));
    ilgen.Emit(OpCodes.Ret);

    demoType.CreateType();
    demoAssembly.Save(asmName.Name + ".dll");
}

ilgen.Emit(OpCodes.Callvirt, TypeBuilder.GetMethod(t_list_type, typeof(MyList<>).GetMethod("Add")));但是在执行过程中，程序在出现以下消息时崩溃：

指定的方法不能是动态的或全局的，并且必须在泛型类型定义上声明

我不明白为什么这段代码在运行时崩溃？因为据我了解，它应该可以工作，为此我专门使用了静态方法TypeBuilder.GetMethod

我实现了关于抛出异常的日志信息（信息包括调用堆栈）。我最近问如何实现调用堆栈记录https://stackoverflow.com/questions/48924449/reliable-way-to-print-exception-backtrace-in-catch-handler。我决定检查 x86 和 x64 平台上的堆栈。比较的结果让我有点吃惊。这是程序：

#include <iostream>
#include <Windows.h>

using namespace std;

struct A
{
};

void foo3()
{
    throw A();
}

void foo2()
{
    foo3(); 
}

void foo1()
{
    foo2();
}

void foo()
{
    try
    {
        foo1();
    }
    catch(...)
    {
        cout << "exception rethrowing" << endl;
        throw;
    }
}
int seh_filter(_EXCEPTION_POINTERS* exception)
{
    cout << "SEH FILTER" << endl;
    return EXCEPTION_EXECUTE_HANDLER;
}

int main(void)
{
    __try
    {
        foo();
    }
    __except(seh_filter(GetExceptionInformation()))
    {
        cout << "SEH catch handler" << endl;
    }
    return 0;
}

设置断点seh_filter以查看堆栈（启动的调试版本）。以下是图片：

我不明白为什么堆栈如此不同（尤其是在 x64 下）。刚刚听说x64下seh异常的处理方式发生了变化。我在 windows 10 下使用 msvc2013。

我在 Windows 上有一个 c++ 程序，我想在其中提供完整的调用堆栈日志记录，以防出现错误（硬件、软件）。是否有可能实现这样的功能？这是包含外部 seh 处理程序的一小段代码：

__try
{
     difficult_task();
}
__except(my_seh_filter(GetExceptionInformation()))
{
    // How to print full backtrace of exception here?
}

我目前所知道的：

1. Windows 提供的 DbgHelp.dll 允许您获取有关调用堆栈的信息（您可以打印堆栈）。
2. SEH 异常处理允许您获取发生异常的上下文。（异常类型、异常地址、抛出异常时的处理器寄存器）。

有一个但是。我想直接在 seh 过滤器或相应的 catch 块中打印调用堆栈。而且我并不完全清楚如何使用这两个工具打印回溯（毕竟，它可能会在堆栈提升时发生变化）。当我在抛出异常的那一刻打印堆栈时，这是一回事。另一个是在处理时（我假设在处理异常时，我将不再拥有有关堆栈的完整信息）。

我知道 gdb 允许您打印使用print <exp>. 然后可以重复使用此结果（通过$N）。现在假设我有以下功能：

const char* foo(){ return "foo";}

char* foo2(){static char b[10]; /*change b*/; return b}

char* foo3(){char* b; /*Create string on heap*/ return b;}

gdb 对命令结果有什么作用print foo(), print foo2(), print foo3()？它将如何释放这些变量，这种清除会导致错误吗？

我正在学习 valgrind 并决定在我的测试用例中尝试它（删除数组中的额外元素）。这是一个示例程序（AMD64/LINUX）

#include <iostream>
using namespace std;

struct Foo
{
    Foo(){ cout << "Creation Foo" << endl;}
    ~Foo(){ cout << "Deletion Foo" << endl;}
};

int main()
{
    Foo* ar = new Foo[3];
    *(reinterpret_cast<int*>(ar)-2) = 4;
    delete[] ar;
    return 0;
}

但是 valgrind 的输出让我吃惊：

$ valgrind --leak-check=full ./a.out -v

==17649== Memcheck，内存错误检测器

==17649== 版权所有 (C) 2002-2017 和 GNU GPL，由 Julian Seward 等人提供。

==17649== 使用 Valgrind-3.13.0 和 LibVEX；使用 -h 重新运行以获取版权信息

==17649== 命令：./a.out -v

==17649==

创造符

创造符

创造符

删除 Foo

删除 Foo

删除 Foo

删除 Foo

==17649==

==17649== 堆摘要：

==17649== 在退出时使用：72,704 字节在 1 个块中

==17649== 总堆使用量：3 次分配，2 次释放，73,739 字节分配

==17649==

==17649== 泄漏摘要：

==17649== 肯定丢失：0 个块中的 0 个字节

==17649== 间接丢失：0 个块中的 0 个字节

==17649== 可能丢失：0 个块中的 0 个字节

==17649== 仍然可以访问：1 个块中的 72,704 个字节

==17649== 抑制：0 个块中的 0 个字节

==17649== 未显示可到达块（找到指针的块）。

==17649== 要查看它们，请重新运行： --leak-check=full --show-leak-kinds=all

==17649==

==17649== 对于检测到和抑制的错误计数，重新运行：-v

==17649== 错误摘要：来自 0 个上下文的 0 个错误（抑制：来自 0 的 0 个）

看起来 valgrind 无法检测到这种危险的内存释放。据我了解，这是一个错误？还是 valgrind 仍然能够检测到这种错误？

UPD：main.cpp通过命令编译g++ -g main.cpp

在阅读 c++11 标准（修订版 N3242）时，我遇到了以下声明：

（12.7 建造和破坏）。对于具有非平凡构造函数的对象，在构造函数开始执行之前引用对象的任何非静态成员或基类会导致未定义的行为。

也就是说，据我了解，以下构造函数代码Foo包含未定义的行为（在初始化站点i）？

struct A
{
    int i;
};

struct Foo
{
    A a;
    int i;
    Foo() : a(), i(a.i)
    {}
};

我一直对这个问题很感兴趣，公司如何在开源项目上赚钱？我有两个猜测（不幸的是我在许可问题上并不强）。

1. 必须有许可证允许您基于开源分发商业软件（例如，无需按需提供源代码）。然后，您可以从中赚钱是很合乎逻辑的。
2. 您可以出售开源维护服务，但不清楚谁愿意为这种服务付费？（虽然在这里，对于我来说，你可以举一个使用开源软件服务服务器的例子）

我正在使用 GIT 系统，我注意到我正在使用一种模式，我想对其进行一些优化以避免将来出现错误。例如，我有一些设置文件Settings.h需要在我工作的一段时间内更改。当我完成后，我想回滚这个文件的更改，我想找到一种方法来防止自己不小心提交更改到这个文件（可能听起来有点奇怪，我明白在提交更改之前，你需要不断地监控你提交的内容，只是我想知道是否有任何方法可以让它更容易一些）

我有一个代码可以创建一个透明的（至少应该）图片（bmp 格式），并将其保存到剪贴板。但是，当尝试将图像插入 Photoshop/Gimp/Office 时，alpha 通道会被忽略。这是代码：

#include <Windows.h>
#include <iostream>
#include <Wingdi.h>
#include <algorithm>

using namespace std;

pair<int, HGLOBAL> dibv5_img(void)
{
    const DWORD width = 100;
    const DWORD height = 100;
    BITMAPV5HEADER header = {0};
    header.bV5Size = sizeof(BITMAPV5HEADER);
    header.bV5Width = width;
    header.bV5Height = -height;
    header.bV5Planes = 1;
    header.bV5BitCount = 32;
    header.bV5Compression = BI_BITFIELDS;
    header.bV5SizeImage = header.bV5Width * header.bV5Height * header.bV5BitCount / 8;
    header.bV5CSType = LCS_WINDOWS_COLOR_SPACE;
    header.bV5Intent = LCS_GM_IMAGES;

    header.bV5BlueMask = 0x000000FF;
    header.bV5GreenMask = 0x0000FF00;
    header.bV5RedMask = 0x00FF0000;
    header.bV5AlphaMask = 0xFF000000;

    DWORD masks[3];
    masks[0] = header.bV5BlueMask;
    masks[1] = header.bV5GreenMask;
    masks[2] = header.bV5RedMask;

    DWORD pixels[width * height];
    for (DWORD i = 0; i < height; ++i)
        for (DWORD j = 0; j < width; ++j)
            pixels[i * width + j] = 0;
    for (DWORD i = height / 4; i < 3 * height / 4; ++i)
        for (DWORD j = 0; j < width; ++j)
            pixels[i * width + j] = (masks[0] | header.bV5AlphaMask) & 0xFFFFFFFF;

    HGLOBAL hmem = GlobalAlloc(GHND | GMEM_DDESHARE, header.bV5Size + sizeof(DWORD) * (3 + width * height));
    PVOID local_pointer = GlobalLock(hmem);

    memcpy(local_pointer, &header, sizeof(BITMAPV5HEADER));
    memcpy(reinterpret_cast<unsigned char*>(local_pointer) + sizeof(BITMAPV5HEADER), masks, sizeof(DWORD) * 3);
    memcpy(reinterpret_cast<unsigned char*>(local_pointer) + sizeof(BITMAPV5HEADER) + sizeof(DWORD) * 3, pixels, 
        sizeof(DWORD) * width * height);
    GlobalUnlock(hmem);
    return pair<int, HGLOBAL>(CF_DIBV5, hmem);
}

int main(void)
{
    cout << sizeof(DWORD) << endl;
    if (!OpenClipboard(0))
        return 1;
    if (!EmptyClipboard())
        return 1;
    const auto data = dibv5_img();
    SetClipboardData(data.first, data.second);
    if (!CloseClipboard())
        return 1;
    return 0;
}

图片本身在任何地方看起来都一样：

有一棵树，每个顶点都有自己的权值，你需要把树分成三个连通的分量，每个分量中所有顶点的总权值是相同的。

应该使用什么算法？

到目前为止，我看到了这样一个解决方案——枚举所有边对，然后进行检查——但就性能而言，这是一个困难的决定。

我正在制作一个剪贴板，我想优化内存分配，或者更确切地说是消除不必要的重新分配。假设我想将图像保存为 png 文件，有没有办法找出未来文件的最大大小？当然，我对某种最优结果很感兴趣（例如，我们可以从上面估计位图的大小——但这没什么用）

刚刚学习如何使用 svn（我以前使用过 git）。不小心将存储库导入到一个空文件夹中（通过导入命令）。现在我正在阅读文档，它说最好使用结账。这些命令之间到底有什么区别？

extern在 C++ 中使用它是否有可能获得任何好处？例如，假设程序不使用全局变量。想到的第一个想法是尝试使用 extern 来使用函数而不在标头中声明它们（这可能会提高编译速度 - 但它也会降低链接速度，例如）。总的来说有点看不懂，可能只是c的雏形，在c++中意义不大。

现在正在研究Ulman的书《Compilers - principles, technologies, tools》。作者介绍了这两个概念，但我无法理解其中的区别。

我想问一下这个使用模式SuppressFinalize。假设我有一个Foo存储某种资源的对象。该对象Foo负责释放分配的资源。我总是使用这种方法：

一个类Foo总是使用释放资源的内部方法来实现finalize和方法。dispose调用时dispose，我总是调用SuppressFinalize该方法（为了优化垃圾收集过程——不需要将此对象存储在终结队列中，或者，例如，如果我忘记显式调用dispose该方法）。

这种方法有什么performance缺点吗？我不明白这种方法是否会产生任何“副作用”——例如，gc此类对象将始终放置在终结队列中

更新：用法示例（用 C++/Cli 编写 -CleanResources未使用复选框，因为没有托管字段）

NativeWrapper::NativeWrapper(void) :
   m_native(new Native())
{
}

NativeWrapper::~NativeWrapper(void)
{
    CleanResources();
    System::GC::SuppressFinalize(this);
}

NativeWrapper::!NativeWrapper(void)
{
CleanResources();
}

void NativeWrapper::CleanResources(void)
{
    delete m_native;
}

我想知道如何最好地实现以下功能。假设一个应用程序有一个菜单。创建应用程序时，会创建此菜单。每个 MenuItem 都包含一个特定的命令。执行某些命令时，应禁用某些菜单项。反之亦然，当执行另一个命令时，可以执行。实现此行为的最佳方法是什么？我看到几个选项：

1. 执行链接。也就是说，使 IsEnabled 属性依赖。每次目标属性发生变化时，依赖属性也会发生变化（我个人是这样理解绑定机制的）
2. 创建一个 MenuItemAccessChanged 事件，在处理该事件时强制更新所有菜单项