更好，或者以不同方式编码类似功能的优点

Question

我正在编写 GUI 代码（用 C++），现在我关心的是文本的行组织。我遇到的问题之一是代码变得非常长且令人困惑，并且我开始进入^2场景，其中对于我为文本演示添加的每个选项，我必须添加的函数数量write 是它的平方。在试图解决这个问题时，出现了一个特定的设计选择，我不知道更好的方法，也不知道它们之间的优点或缺点的程度：

我有两种在流程上非常相似的方法，即迭代通过相同的对象，考虑相同的约束，但最终在此流程之间执行不同的操作。为了满足任何人的兴趣，这些方法渲染文本，并确定是否有任何文本由于文本环绕其他对象或简单地分别位于行尾而溢出行。

这些函数需要针对左、右或居中文本进行复制和重写，这些文本具有不同的流程，因此无论我做出什么设计选择都会重复三次。

基本上，我可以继续我现在所拥有的，这是两种单独的方法来处理这些不同的操作，或者我可以将它们合并到一个函数中，该函数中包含 if 语句来确定是否渲染文本或找出是否存在文字溢出。

有没有普遍接受的正确方法来解决这个问题？否则，需要进行哪些权衡，有哪些迹象可能表明应该使用一种方法而不是另一种方法？还有其他方法可以做我错过的事情吗？

我已经对其进行了几次编辑，试图使其更容易理解，但如果不是，请问我一些问题，以便我可以编辑和解释。我还可以发布两种不同方法的源代码，但它们使用了很多函数和对象，需要很长时间才能解释。

// 编辑：源代码 //

函数 1：

void GUITextLine::renderLeftShifted(const GUIRenderInfo& renderInfo) { if(m_renderLines.empty()) 返回；

Uint iL = 0;

Array2t<浮点>渲染坐标；
renderCoords.s_x = renderInfo.s_offset.s_x + m_renderLines[0].s_x;
renderCoords.s_y = renderInfo.s_offset.s_y + m_y;
浮动剩余像素InLine = m_renderLines[0].s_y;

for (Uint iTO= 0;iTO != m_text.size();++iTO)
{
    if(m_text[iTO].s_pixelWidth <=剩余像素内行)
    {
        字符串预览 = m_text[iTO].s_string;

        m_text[iTO].render(&renderCoords);
        剩余像素InLine -= m_text[iTO].s_pixelWidth;
    }

    别的
    {
        FSInternalGlyphData intData = m_text[iTO].stealFSFastFontInternalData();

        浮点字符宽度=0；

        Uint iFirstCharacterOfRenderLine = 0;

        for(Uint iC = 0;;++iC)
        {
            if(iC == m_text[iTO].s_string.size()) 
            {
                // 包起来
                字符串 renderPart = m_text[iTO].s_string;
                renderPart.erase(iC, renderPart.size());
                renderPart.erase(0, iFirstCharacterOfRenderLine);
                m_text[iTO].s_font->renderString(renderPart.c_str(), intData,
                    &渲染坐标);
                休息;
            }

            字符宽度 += m_text[iTO].s_font->getWidthOfGlyph(intData,
                m_text[iTO].s_string[iC]);

            if(字符宽度>剩余像素行) 
            {
                // 无法压入最后一个字符
                // 该行不再有空格

                // 首先，渲染我们已有的内容：

                字符串 renderPart = m_text[iTO].s_string;
                renderPart.erase(iC, renderPart.size());
                renderPart.erase(0, iFirstCharacterOfRenderLine);
                m_text[iTO].s_font->renderString(renderPart.c_str(), intData,
                    &渲染坐标);


                if(++iL != m_renderLines.size())
                {
                    剩余像素InLine = m_renderLines[iL].s_y;
                    renderCoords.s_x = renderInfo.s_offset.s_x + m_renderLines[iL].s_x;

                    // 很酷，现在尝试再次渲染这个角色
                     - 我知道了;
                    iFirstCharacterOfRenderLine = iC;
                    字符宽度=0；
                }
                别的
                {

                    // 辞职

                    休息;
                }
            }
        }
    }
}

// 完毕！ }

功能2：

向量 GUITextLine::recalculateWrappingContraints_LeftShift() { m_pixelsOfCharacters = 0;

浮动像素剩余 = m_renderLines[0].s_y;

单位 iRL = 0;

// 遍历每个文本对象，将它们放入渲染线中
for(Uint iTO = 0;iTO != m_text.size();++iTO)
{
    // 如果整个文本对象适合一行
    if(剩余像素>= m_text[iTO].s_pixelWidth)
    {
        剩余像素 -= m_text[iTO].s_pixelWidth;
        m_pixelsOfCharacters += m_text[iTO].s_pixelWidth;
    }

    // 否则，逐个字符
    别的
    {
        // 现在获取一些数据，我们并不是每次函数调用都获取它
        FSInternalGlyphData intData = m_text[iTO].stealFSFastFontInternalData();

        for(Uint iC = 0; iC != m_text[iTO].s_string.size();++iC)
        {
            浮点字符宽度 = m_text[iTO].s_font->getWidthOfGlyph(intData, '-');

            if(字符宽度 < 剩余像素)
            {
                剩余像素 -= 字符宽度；
                m_pixelsOfCharacters += 字符宽度；
            }

            else // 渲染行结束！ 
            {
                m_pixelsOfWrapperCharacters += 剩余像素； // 我们可以跟踪我们使用了多少包装像素

                // 如果这是真的，那么我们在用完文本之前就用完了渲染线。意味着我们有一些溢出要返回
                if(++iRL == m_renderLines.size())
                {
                    返回 HarvesOverflowFrom(iTO, iC);
                }

                别的
                {
                    剩余像素 = m_renderLines[iRL].s_y;
                }
            }
        }

    }
}

矢量空溢出；
返回空溢出； }

所以基本上，render() 将 renderCoordinates 作为参数，并从中获取需要渲染的全局位置。 calcWrappingConstraints 计算出对象中有多少文本超出了分配的空间，并将该文本作为函数返回。

m_renderLines 是两个浮点结构的 std::vector，其中 .s_x = 渲染可以开始的位置，.s_y = 渲染空间有多大 - 不是，它本质上是“renderLine”的宽度，而不是它结束的位置。

m_text 是 GUIText 对象的 std::vector，其中包含文本字符串和一些数据，如样式、颜色、大小等。它还在 s_font 下包含对字体对象的引用，该对象执行渲染、计算字形的宽度等。

希望这能澄清事情。

Answer 1

在这种情况下没有普遍接受的方法。
然而，任何编程场景中的常见做法都是删除重复的代码。
我认为当方向对结果的改变太大而无法进行这种划分时，您会陷入如何按方向划分代码的困境。在这些情况下，重点关注三种算法的共同部分，并将它们划分为任务。

当我为 MFC 复制 WinForms 流布局控件时，我做了类似的事情。我处理两种类型的对象：固定位置（您的图片等）和自动位置（您的文字）。

在您提供的示例中，我可以列出示例的常见部分。

Write Line (direction)

• bool TestPlaceWord (direction) // 如果无法将单词放在前一个单词旁边，则返回 false
• bool WrapPastObject (direction) // 如果超出行，则返回 false
• bool WrapLine (direction) // 如果运行则返回 false没有空间容纳新行。

无论您面对什么方向，都会执行这些操作中的每一个。

最终，每个方向的算法差异太大，无法再简化。

Answer 2

访客模式的实现怎么样？听起来这可能就是你所追求的东西。