Question

给出以下代码：

add(ss >> ?, ss >> ?) // ? because I don't know what'd you'd put there.

我想知道是否有任何方法可以减少这里的部分：

    Private Sub Worksheet_SelectionChange(ByVal Target As Range)

    ActiveSheet.Unprotect "password"

    On Error Resume Next
    Range("PrevCell").Interior.ColorIndex = 0

    ActiveCell.Interior.ColorIndex = 3
    With ActiveWorkbook.Names("PrevCell")
        .RefersTo = ActiveCell
    End With

    ActiveSheet.Protect Password:="password", DrawingObjects:=True, Contents:=True, Scenarios:=True _
        , AllowSorting:=True, AllowFiltering:=True, AllowUsingPivotTables:=True
End Sub

并减少要添加到以下内容的调用：

calculateSum(5) -> returns 5^1 = 5
12 -> 1^1 + 2^2 = 5
26 -> 2^1 + 6^2 = 38
122 -> 1^1 + 2^2 + 2^3 = 13

基本上，把它变成一个单行。

Answer 1

您可以创建一个功能

int getInt(std::istream& instr)
{
   int n;
   instr >> n;
   return n;
}

然后使用

printf("Result: %d\n", add(getInt(ss), getInt(ss)));

<强> PS

如果对add的参数的评估顺序很重要，那么这种方法就不会起作用。例如，您无法使用：

printf("Result: %d\n", subtract(getInt(ss), getInt(ss)));

其中subtract具有通常的含义。

您当然可以使用：

int a = getInt(ss);
int b = getInt(ss);
printf("Result: %d\n", add(a, b));
printf("Result: %d\n", subtract(a, b));

Answer 2

据我了解你的问题，你想知道是否有办法减少像

这样的东西

int a, b;
ss >> a >> b;
cout << (a + b) << endl;

之类的（请注意，这只是伪代码）

cout << ((ss >> ?) + (ss >> ?)) << endl;

没有办法绕过声明临时变量。首先，正如其他人所指出的那样，如果操作的顺序很重要，则需要它们。其次，你需要在操作员的右侧有一个名字。

您可以手动指定临时名称，但仍需指定其类型。 C ++是一种静态类型语言。 operator>>无法在右侧为您创建动态推导类型的变量。

就像好奇心一样，这是我尝试将几个变量从流中读取到仅仅是类型规范的尝试

#include <iostream>
#include <tuple>

template <size_t I=0, typename... T>
std::enable_if_t<I==sizeof...(T)>
collect_impl(std::istream& s, std::tuple<T...>& vars) { }
template <size_t I=0, typename... T>
std::enable_if_t<I!=sizeof...(T)>
collect_impl(std::istream& s, std::tuple<T...>& vars) {
  s >> std::get<I>(vars);
  collect_impl<I+1>(s,vars);
}

template <typename... T>
auto collect(std::istream& s) {
  std::tuple<T...> vars;
  collect_impl(s,vars);
  return vars;
}

void awesome_function(std::tuple<int,int> ii) {
  std::cout << std::get<0>(ii) << ' ' << std::get<1>(ii) << std::endl;
}

void less_awesome_function(int i2, int i1) {
  std::cout << i1 << ' ' << i2 << std::endl;
}

int main() {
  const auto ii = collect<int,int>(std::cin);
  std::cout << std::get<0>(ii) << ' ' << std::get<1>(ii) << std::endl;

  // we can also do
  awesome_function(collect<int,int>(std::cin));

  // with C++17 apply we can even do this
  std::apply(less_awesome_function,collect<int,int>(std::cin));
}

Answer 3

你的意思是这样的吗？

NULL

Answer 4

好吧，您可以定义一个重载方法，如：

int add(const std::string & str ) 
{
    std::stringstream ss(str); 
    int a, b,sum; 
    ss >> a; ss >> b;
    return add(a, b);
}

减少将参数传递给函数所需的字符串流操作的详细程度

4 个答案: