C++ 在C+中找出3个数字中最小的一个+；

有没有办法让这个功能更优雅？我是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;
}

float最小值（整数x，整数y，整数z）{
int=99999；
if（x<最小值）
最小=x；
if（y<最小值）
最小=y；
if（z<最小值）
最小=z；
返回最小；
}

一个小小的修改

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

---

我们可以做很多改进

您可以使用标准函数使其更清晰：

// 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上运行，可以执行以下操作：

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;
}

int最小值（const std:：vector和intvec）{
int minimest=std:：numeric_limits:：max（）；//可能的最大整数
//有很多方法可以构造这个循环，这只是其中之一
对于（inti=0；i

您还可以将其设置为泛型，以便它可以对任何类型进行操作，而不仅仅是int

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;
}

模板
T最小值（常数标准：：向量和向量）{
T minimest=std:：numeric_limits:：max（）；//可能的最大整数
//有很多方法可以构造这个循环，这只是其中之一
对于（int i=0；i

分离最小值，让您写入返回最小值（x，min（y，z）），有三元运算符：

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

float最小值（整数x，整数y，整数z）{
返回x

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

您应该将这三个值一起比较。另外，您得到的是

int

，但返回的是

float

。或者，您应该决定要处理哪种类型的值，或者您可以创建一个通用版本，该版本可以与任何可以比较的类型一起工作：

#包括
模板
T最小（tx，tyz）
{
返回std:：min（x，std:：min（y，z））；
}

编辑：

有两种方法可以将代码改进为在

向量上运行的代码：

#包括
#包括
#包括
//使用内置函数自动检索最小值
模板
T smallest1（常量标准：：向量和值）
{
return*std:：min_元素（values.begin（）、values.end（））；
}
//手动检查向量
模板
T smallest2（常量标准：：向量和值）
{
//获取第一个值，以确保与实际值进行比较
T best_so_far=values.front（）；
//对于向量中的所有其他值。。。
for（无符号i=1；i > p>有一个建议将它包含到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 ...); }

模板
常数T&min（常数T&a）
{返回a；}
模板
常数T&min（常数T&a、常数T&b、常数参数和…参数）
{返回std：：min（b
最小=（x1）简单解决方案：

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

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

float最小值（整数x，整数y，整数z）
{
返回x

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

int最小值（int x，int y，int z）
{
int=x；
if（y<最小值）
最小=y；
if（z<最小值）
最小=z；
返回最小；
}

4） 任意数量的数字：

对于n个数字，将其存储在一个数组中（数组[n]），对数组进行排序并
取数组[0]以获取最小值

//按升序对元素排序
对于（int i=0；iarray[i+1]）
{
int temp=数组[i]；
数组[i]=数组[i+1]；
阵列[i+1]=温度；
}
}
//显示最小值和最大值
cout或者您可以使用define来创建宏函数

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

定义最小值（x，y，z）（x
如果可能，我建议使用C++11或更新版本，它允许您在实现自己的函数（）的同时计算所需的结果。正如其中一条评论中已经指出的，您可以这样做

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

或

它存储
T
类型的变量
minimum
中变量
x
、
y
和
z
的最小值（注意
x
、
y
和
z
必须具有相同的类型或必须隐式转换为该类型）。相应地，也可以这样做以获得最大值：
std:：max（{x，y，z}）
您可以将它们存储在向量中，并在该向量上使用
std:：min_元素

例如：

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

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

向量值；
值。推回（10）；值。推回（1）；值。推回（12）；
int min=*std:：min_元素（values.begin（），values.end（））；
哈哈，如果没有一个值小于99999怎么办？ha.@jogojapan或优于以
INT\u MAX
开头（或
std:：numeric\u limits:：MAX（）开头）<代码> >从第一个数字开始……我不确定由于C++上下文关闭这个是个好主意。我想在引用的DUP中看到泛型讨论；我也希望看到C++与模板和元编程的讨论；C++ 11讨论与代码> CONTXPRPR <代码>。S<代码> max 而不是<代码> min <代码>：它看起来更好，因为它是C++专用的。
int smallest(int x, int y, int z)
{

  int smallest = x;

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

    //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
    }

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

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

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

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

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