首先，你应该在一个单独的类中收集这些参数：

class Configuration // maybe you find a better name...
{
    int m_servicechrg = 10; // default
    int m_freight = 20;
    // ...
public:
    int servicechrg() { return m_servicechrg; }
    void servicechrg(int value); { /* check some limits? */ m_servicechrg = value; }
    int freight() { return m_freight; }
    void freight(int value); { /* check some limits? */ m_freight = value; }
    // ...
};
// will allow you to do:
// C c; std::cout << c;
ostream& operator<<(ostream& s, Configuration const& c)
{
    // which ever formatting is appropriate...
    s << c.servicechrg() << ' ' << c.freight();
    return s;
}

字符串
setter也可以返回bool来指示无效值。
现在你可以在main中使用这个类：

Configuration c;
A a;
int cost = a.exportCost(c); // you'd have to adjust signatures...
int value;
switch(ch)
{
case 4:
    if(stc::cin >> freight) // catches invalid user input!
                            // one ALWAYS should do, otherwise you might end up in
                            // your program not working any more
    {
        c.freight(value);
        // or, if you have:
        if(!c.freight(value))
        {
            // some appropriate error message
            // (it's better not to output in the setter, you are more flexible this
            // way – maybe you want different messages at different occasions?)
        }
    }
    else
    {
        // appropriate error handling
    }
    break;
default:
    // handling invalid user input
    // again, you always should; but stream state is not in error state,
    // so you just can print appropriate error message
    break;
}

型
请参阅this answer了解如何正确处理流错误。
如果你想知道错误处理的差异：第一种情况是，如果用户输入非数字输入，如ss，第二种情况是，如果输入 * 是 * 数字，但超出有效范围（77）。
现在，如果你不想一直将配置作为参数传递，你可以从（但要小心，全局变量有一些危险，尽可能少地使用它们）或实现singleton pattern。
旁注：goto * 有时候是一个很好的工具，但它是一个危险的工具（标签的名字x不是一个好的，更喜欢一个明确表明意图的名字，如REENTRY_POINT，LOOP_START，.）。如果你可以沿着而不需要不合理的努力，更喜欢这样的变体：

bool isRunning = true;
do
{
    // ...
    case 2:
        isRunning = false;
        break;
}
while(isRunning);

型
当然，一个额外的变量，一个额外的检查;不幸的是，你不能使用break退出（伪）无限循环（for(;;)）（但不要将这种模式应用于嵌套循环，那么它会变得越来越不可读和低效：bool isExit = false; for(int i = 0; !isExit && i < n; ++i) { for(j = 0; j < n; ++j) { isExit = true; break; } }-明白我的意思吗？）。一个变体可能是：

for(;;)
{
    switch(ch)
    case 1:
        // ...
        //break; <- replace
        continue;
    case 2:
        //
        break;
    } // end of switch
    break; // break the surrounding for(;;) loop
}

型
但这也不太好。
一个非常好的变体，允许在给定的情况下退出循环，因为之后没有任何事情要做：

for(;;)
{
    switch(ch)
    {
    case 2:
        // maybe yet some cleaning up here
        return 0;
    default:
        // ...
        break;
    }
}

型
缺点：函数的退出点可能深深地嵌套在代码中。
还有其他的技巧来允许这种模式，比如将代码的子部分打包在一个lambda中，并在其中返回，然后直接调用它。
最后，如果你坚持goto，我的变体更倾向于：

for(;;)
{
    switch(ch)
    {
    case 2:
        // ...
        goto LOOP_EXIT;
    default:
        // ...
        break;
    }
}
LOOP_EXIT:
return 0; // e. g. main
(void)0;  // if there isn't anything to do in the function any more
          // (labels require an instruction afterwards!)

型
现在不会有隐藏循环了，你实际上在做什么变得更加明显。目前，这不是一个真正的问题，但如果你的代码增长，隐藏循环会变得越来越难以发现。
在这种情况下，我清楚地标记goto s，以便另一个编码器可以立即发现关键代码点：

///////////////////////////////////////////////////
// possibly some comment why applying this pattern
goto SOME_LABEL;
///////////////////////////////////////////////////

型
可以对深度嵌套的函数出口点（return）做同样的事情。