Question

有没有办法让这个功能更优雅？我是C ++的新手，我不知道是否有更标准化的方法来做到这一点。这可以变成一个循环，所以变量的数量不受我的代码限制吗？

float smallest(int x, int y, int z) {

  int smallest = 99999;

  if (x < smallest)
    smallest=x;
  if (y < smallest)
    smallest=y;
  if(z < smallest)
    smallest=z;

  return smallest;
}

Answer 1

可以做出许多改进。

您可以使用标准功能使其更清晰：

// Notice I made the return type an int instead of a float, 
// since you're passing in ints
int smallest(int x, int y, int z){
    return std::min(std::min(x, y), z);
}

或者更好的是，正如评论中指出的那样：

int smallest(int x, int y, int z){
    return std::min({x, y, z});
}

如果您希望它以任意数量的整数运行，您可以执行以下操作：

int smallest(const std::vector<int>& intvec){
    int smallest = std::numeric_limits<int>::max(); // Largest possible integer
    // there are a number of ways to structure this loop, this is just one
    for (int i = 0; i < intvec.size(); ++i) 
    {
        smallest = std::min(smallest, intvec[i]);
    }
    return smallest;
}

您也可以将其设为通用的，以便它可以在任何类型上运行，而不仅仅是整体

template <typename T>
T smallest(const std::vector<T>& vec){
    T smallest = std::numeric_limits<T>::max(); // Largest possible integer
    // there are a number of ways to structure this loop, this is just one
    for (int i = 0; i < vec.size(); ++i) 
    {
        smallest = std::min(smallest, vec[i]);
    }
    return smallest;
}

Answer 2

如果可能，我建议使用C ++ 11或更新版本，它允许您计算所需的结果，而无需实现您自己的功能（std::min）。正如其中一条评论中已经指出的那样，你可以做到

T minimum(std::min({x, y, z}));

或

T minimum = std::min({x, y, z});

将变量x，y和z的最小值存储在minimum类型的变量T中（请注意x ，y和z必须具有相同的类型，或者必须可以隐式转换为它。相应地，可以采用相同的方法来获得最大值：std::max({x, y, z})。

Answer 3

除了min，让你写回返min（x，min（y，z））有三元运算符：

float smallest(int x, int y, int z){
  return x < y ? (x < z ? x : z) : (y < z ? y : z);
}

Answer 4

smallest=(x<((y<z)?y:z)t)?x:((y<z)?y:z);

假设，

x is one;
y is two;
z is three;

smallest = (one < ((two < three) ? two:three)) ? one:((two < three) ? two:three)

Answer 5

有人建议将其包含在N2485下的C ++库中。提案很简单，所以我在下面列出了有意义的代码。显然，这假定了可变参数模板。

template < typename T >
const T & min ( const T & a )
{ return a ; }

template < typename T , typename ... Args >
const T & min ( const T & a , const T & b , const Args &... args )
{ return std :: min ( b < a ? b : a , args ...); }

Answer 6

一个小修改

 int smallest(int x, int y, int z){
    int smallest = min(x,y);
    return min(smallest,z);
    }

Answer 7

在您的版本中，只有当它小于99999时才会找到最小值。

您应该将所有三个值进行比较。此外，您收到int但返回float。或者，您应该决定要处理哪种值，或者您可以创建适用于任何可比较类型的通用版本：

#include <algorithm>

template<class T>
T smallest(T x, T y, T z)
{
  return std::min(x, std::min(y, z));
}

编辑：

将代码改进为vector上的代码的两种方法：

#include <cstdio>
#include <algorithm>
#include <vector>

// Use a built-in function to retrieve the smallest value automatically
template<class T>
T smallest1(const std::vector<T> &values)
{
  return *std::min_element(values.begin(), values.end());
}

// Go through the vector manually
template<class T>
T smallest2(const std::vector<T> &values)
{
  // Get the first value, to make sure we're comparing with an actual value
  T best_so_far = values.front();
  // For all the other values in the vector ...
  for(unsigned i = 1; i < values.size(); ++i) {
    // ... replace if the new one is better
    if(values[i] < best_so_far)
      best_so_far = values[i];
  }
  return best_so_far;
}

int main()
{
  // Try out the code with a small vector
  std::vector<int> test;
  test.push_back(6);
  test.push_back(5);
  test.push_back(7);

  printf("%d\n", smallest1(test));
  printf("%d\n", smallest2(test));

  return 0;
}

Answer 8

1）简单的解决方案：

int smallest(int x, int y, int z)
{
    return std::min(std::min(x, y), z);
}

2）更好的解决方案（在优化方面）：

float smallest(int x, int y, int z)
{
  return x < y ? (x < z ? x : z) : (y < z ? y : z);
}

3）您的解决方案已修改（简单但效率不高）：

int smallest(int x, int y, int z)
{

  int smallest = x;

  if (y < smallest)
     smallest=y;
  if(z < smallest)
     smallest=z;
  return smallest;
}

4）任意数量的数字：

对于n个数字，将其存储在数组（array [n]）中，对数组进行排序使数组[0]变得最小。

    //sort the elements in ascending order
    for(int i=0;i<n;i++)
    {
      if(array[i]>array[i+1])
      {
        int temp = array[i];
        array[i] = array[i+1];
        array[i+1] = temp;
      }
    }

    //display smallesst and largest
    cout<<"Smallest: "<<array[0];
    cout<<"Largest: "<<array[n-1];   //not needed in your case
    }

Answer 9

或者您可以使用define来创建宏功能。

#define min(x,y,z) (x < y ? (x < z ? x : z) : (y < z ? y : z))

Answer 10

您可以将它们存储在矢量中并使用std::min_element。

例如：

vector<int> values;
values.push_back(10);values.push_back(1);values.push_back(12);

int min = *std::min_element(values.begin(),values.end());

找到C ++中3个数字中最小的数字

10 个答案: