C++ 这是最好的方法吗；加上；C++；？

编辑：

所以这个问题被误解到了荒谬的程度，以至于它不再有意义了。我不知道如何，因为我实际问的问题是我具体执行的是，是没有意义的，是的，不是像惯用的C++宏那样好，它是否必须使用<代码> Auto <代码>，或者是否有合适的解决方法。这本不应该引起如此多的关注，当然也不是如此严重的误解。要求受访者编辑他们的答案是毫无意义的，我不想让任何人因为这件事而失去声誉，而且这里有一些好的信息在为未来的潜在观众提供，所以我会任意选择一个投票率较低的答案来平均分配所涉及的声誉。往前走，这里没什么可看的

---

我看到并决定在C++中用语句编写<代码>可能会很有趣。

auto

关键字使这项工作变得非常简单，但是有没有更好的方法可以做到这一点，也许不用

auto

？为了简洁起见，我省略了一些代码

template<class T>
struct with_helper {

    with_helper(T& v) : value(v), alive(true) {}

    T* operator->() { return &value; }
    T& operator*() { return value; }

    T& value;
    bool alive;

};


template<class T> struct with_helper<const T> { ... };


template<class T> with_helper<T>       make_with_helper(T& value) { ... }
template<class T> with_helper<const T> make_with_helper(const T& value) { ... }


#define with(value) \
for (auto o = make_with_helper(value); o.alive; o.alive = false)

---

我选择了

o

，因为它是一个不常见的标识符，它的形式给人一种“一般事物”的印象。如果你有一个更好的标识符或更有用的语法的想法，那么请提出建议。

如果你使用

auto

，为什么要使用宏呢

int main()
{
    std::vector<int> vector_with_uncommonly_long_identifier;

    {
        auto& o = vector_with_uncommonly_long_identifier;

        o.push_back(1);
        o.push_back(2);
        o.push_back(3);
    }

    const std::vector<int> constant_duplicate_of_vector_with_uncommonly_long_identifier
        (vector_with_uncommonly_long_identifier);

    {
        const auto& o = constant_duplicate_of_vector_with_uncommonly_long_identifier;

        std::cout
            << o[0] << '\n'
            << o[1] << '\n'
            << o[2] << '\n';
    }

    {
        auto o = constant_duplicate_of_vector_with_uncommonly_long_identifier.size();
        std::cout << o <<'\n';
    }
}

对于C++0x（假设为）：

intmain（）{
std：：向量向量向量，带有非常长的标识符；
{
auto&o=带有异常长标识符的向量；
o、 推回（1）；
o、 推回（2）；
o、 推回（3）；
}
}

为什么不使用好的lambda

auto func = [&](std::vector<int>& o) {
};
func(vector_with_a_truly_ridiculously_long_identifier);

auto-func=[&]（标准：：向量&o）{
};
func（带有真正长标识符的向量）；

---

一个简单的事实是，如果您的标识符太长，无法每次都将其键入，请使用引用、函数、指针等来解决此问题，或者更好地重构名称。像这样的语句（例如，在C#中使用（）会产生额外的副作用（在我的示例中是确定性清理）。C++中的语句没有显著的实际好处，因为它实际上不调用任何附加的行为来防止编写代码。

？尝试将vb语法转换为C++

with

表示默认情况下执行以下块中的所有操作，引用我说过要使用的对象，对吗

那么这个例子是如何给出相同的语法的呢

给我举个例子，说明为什么要使用where多个反引用访问

所以而不是

book.sheet.table.col(a).row(2).setColour
book.sheet.table.col(a).row(2).setFont
book.sheet.table.col(a).row(2).setText
book.sheet.table.col(a).row(2).setBorder

你有

with( book.sheet.table.col(a).row(2) )
  .setColour
  .setFont
  .setText
  .setBorder

看起来同样简单，C++中的更常见的语法是

cell& c = book.sheet.table.col(a).row(2);
c.setColour
c.setFont
c.setText
c.setBorder

---

谢谢……看起来很有趣也很有用。@Robert Harvey:它基本上只是

{[const]auto&o=…；…}

的简写，但不那么难看。你是说

#define with（value）\

而不是

#define with（value，id）\

？顺便说一句，Boost.Typeof怎么样？@KennyTM：是的，测试中的复制错误。谢谢你帮我接过来。Boost.Typeof并不理想，因为它不能与用户定义的类型一起开箱即用，这是

with

@CiscolPPhone:Done和Done最重要的用途之一谢谢，但我实际上并没有假设C++0x。也许这还不清楚。@Jon:

auto

，因为自动类型推断是C++0x。干杯，@Alf P.Steinbach：我在寻找一个非自动解决方案，因此，特别是非C++0x。但是我放弃了。@Jon：只要做

std:：vector&

而不是

auto&

。或者，如果类型规范本身很长，则也为该类型添加一个

typedef

。干杯，嗯。@Jon:我认为你没有道理。你在用相当复杂的Rube Goldberg结构做一件非常琐碎的事情。然后你说没人理解你，我已经想到了。我已经提过了。这并不是我真正想问的。这种方法的问题是它使代码更难阅读——你必须向下跳转到lambda定义的底部，找到正在作用的对象，然后再向上跳转，找出代码对该对象做了什么，Adam Rosenfield：它的另一个优点是可以通过使用std:：function动态地传递func，而不仅仅是按顺序读取代码。此外，OP的整个非真正的问题是荒谬的。你在期待一个非荒谬的解决方案吗？@Adam Rosenfield，@DeadMG:Jeez，我只是想让bug知道我写的显然是故意无用的宏是否写得像它可能写的那样好，然后一系列不相关的答案接踵而至。我不想删除这个问题，但这已经没有意义了。

with(a)
 .do
 .domore
 .doitall

book.sheet.table.col(a).row(2).setColour
book.sheet.table.col(a).row(2).setFont
book.sheet.table.col(a).row(2).setText
book.sheet.table.col(a).row(2).setBorder

with( book.sheet.table.col(a).row(2) )
  .setColour
  .setFont
  .setText
  .setBorder

cell& c = book.sheet.table.col(a).row(2);
c.setColour
c.setFont
c.setText
c.setBorder