C++ 臃肿的对象文件需要多少成本？

在处理嵌入式项目时，我遇到了一个函数，它在应用程序的生命周期中被调用了数千次，通常是循环调用，每秒调用几十次。我想知道是否可以降低它的成本，我发现，它的大多数参数在编译过程中都是已知的

让我用一个例子来说明这一点

原始hpp/cpp文件可以近似如下：

原件.hpp：

void example(bool arg1, bool arg2, const char* data); magic.cpp：

#include "ex1.hpp"    
#include <iostream>

template<bool arg1, bool arg2>
struct Processor;

template<>
struct Processor<true, true>
{
    static void process(const char* data)
    {
        std::cout << "Both true " << data << std::endl;
    }
};

template<>
struct Processor<false, true>
{
    static void process(const char* data)
    {
        std::cout << "False and true " << data << std::endl;
    }
};

template<>
struct Processor<true, false>
{
    static void process(const char* data)
    {
        std::cout << "True and false " << data << std::endl;
    }
};

template<>
struct Processor<false, false>
{
    static void process(const char* data)
    {
        std::cout << "Both false " << data << std::endl;
    }
};

template<bool arg1, bool arg2>
void example(const char* data)
{
    Processor<arg1, arg2>::process(data);
}

template void example<true, true>(const char*);
template void example<false, true>(const char*);
template void example<true, false>(const char*);
template void example<false, false>(const char*);

#包括“ex1.hpp”
#包括
样板
结构处理器；
样板
结构处理器
{
静态无效进程（常量字符*数据）
{
std:：cout增加二进制大小的问题几乎从来都不是文件本身的存储问题——问题是，更多的代码意味着缓存中的程序指令在任何时候都有较低的百分比可用，从而导致缓存未命中。如果在紧循环中调用相同的实例化，那么让它做较少的工作是很好的。但是如果在不同的模板实例化之间不断跳转，那么到主内存加载指令的成本可能远远高于从函数内部删除一些指令所节省的成本

然而，这类事情很难预测。如何在其中找到最佳点（以及任何最佳点）优化的类型是测量。它也可能在不同平台上发生变化——特别是在嵌入式世界中。
是什么让你认为OP使用的是带有数据或指令缓存的系统？他说他使用的是微控制器。微控制器可以是古董8051到Cortex a或PowerPC。我不明白这是如何回答这个问题的。ICa现在可以确认存在一点缓存，虽然它可能很小，所以这可能是一个问题。这个答案对其他有类似问题的人也很有用。最后，这个概念被放弃了。
template<bool arg1, bool arg2>
void example(const char* data);

#include "ex1.hpp"    
#include <iostream>

template<bool arg1, bool arg2>
struct Processor;

template<>
struct Processor<true, true>
{
    static void process(const char* data)
    {
        std::cout << "Both true " << data << std::endl;
    }
};

template<>
struct Processor<false, true>
{
    static void process(const char* data)
    {
        std::cout << "False and true " << data << std::endl;
    }
};

template<>
struct Processor<true, false>
{
    static void process(const char* data)
    {
        std::cout << "True and false " << data << std::endl;
    }
};

template<>
struct Processor<false, false>
{
    static void process(const char* data)
    {
        std::cout << "Both false " << data << std::endl;
    }
};

template<bool arg1, bool arg2>
void example(const char* data)
{
    Processor<arg1, arg2>::process(data);
}

template void example<true, true>(const char*);
template void example<false, true>(const char*);
template void example<true, false>(const char*);
template void example<false, false>(const char*);