C++ 如果方法'；从动态分配的对象调用（编译器优化）

如果我有此代码：

class MyClass;

class Child   
{  
public:   
    void ExecuteChild()   
    {   
       parent->ExecuteParent(); //This function   
    }

MyClass* parent;   
};

class MyClass    
{    
 public:
   MyClass    
{   
   child = newChild();
   chilt->parent = this;    
}

   void ExecuteParent()    
{       
//does something    
} 

Child* child

};

std::vector<MyClass*> objects;
int num = GetRandomNumberBetween5and10();
for(int i = 0; i < num; i++)
{
  objects.push_back(new MyClass());
}

for(int i = 0; i < num; i++)
{
  objects[i]->Execute());
}

class-MyClass；
班童
{  
公众：
void ExecuteChild（）
{   
parent->ExecuteParent（）；//此函数
}
MyClass*父级；
};
类MyClass
{    
公众：
我的班级
{   
child=newChild（）；
chilt->parent=这个；
}
void ExecuteParent（）
{       
//做点什么
} 
孩子
};
向量对象；
int num=getrandomnumberbetween 5和10（）；
for（int i=0；iExecute（））；
}

---

在一个启用了所有优化的现代C++编译器下，有没有可能：子：：ExuuTePARTENTHER（）被内联？我问这个问题，因为我在我的项目中有一个类似的情况，在一个非常高性能的地方，我必须知道是否有任何点继续这个设计。调用

parent->ExecuteParent（）

时，未定义

MyClass

。也就是说，如果对声明和定义的顺序进行了排序，并且函数被适当地定义为

inline

，编译器就可以将它们内联：方法

ExecuteParent（）

和

ExecuteChild（）

在编译时是已知的，它们不是

虚拟的

。编译器是否将内联函数是另一回事。

原则上我认为方法调用可以内联，因为编译器确实知道

对象[I]

的类。 如果它真的做到了，我会感到惊讶

当你有一个你称之为“非常性能密集点”的地方时，我开始有一点过早优化的感觉，我将其定义为在你确定是否是一个性能问题之前解决一个性能问题

性能问题之所以如此，是因为你不知道它们在哪里。 它们在你不知情的情况下隐藏在你的代码中。 有时，试图解决想象中的性能问题会导致性能问题的产生。 更重要的是，在我的经验中，从来没有一个是这样的

例如，假设您有三个性能问题：

• 一个你不知道的50%的人在那里
• B你怀疑有25%的人在那里
• C占12.5%，你不知道那里有

那么你的策略是什么

如果你过早地修复了B，你将节省25%，比没有修复它的速度提高1.33倍。 你会很高兴的，但是

如果你遵循我推荐的诊断过程，这并不意味着你不去治疗B。 这意味着首先让诊断让你惊讶，指出A。 如果你先解决这个问题，你可以节省50%，这将使你的速度提高2倍

更重要的是，当你再次进行诊断时，它说现在B占用了50%的时间，而不是25%，所以它不仅告诉你你是对的，修复它会让你的速度增加2倍，而不仅仅是1.33倍。因此，在修复A和B之后，您的速度将提高4倍。 （当然，如果先固定B，然后固定A，那么最终将在同一个位置。）

最后，不管你是否猜到C是一个问题，但不是一个很大的问题，现在它是一个很大的问题，因为你已经修复了a和B。现在C需要50%的时间，而不是12.5%，所以修复它会给你另外2倍的加速。 现在你比开始时快了8倍

这都是你用来发现你没有预料到的问题的方法的结果。 钱就在那里。 ，通过解决连续六个问题，其中一些问题在开始时非常小，但加在一起，它们加起来占99.8%以上的时间

当然，您可以从中学习，避免陷阱，并从一开始就编写更快的代码，我想您可以称之为过早优化：）