## C++ min() Function

There are many inbuilt comparator functions in C++ that compare two or more values with each other. One such function is the C++ min() function. The article contains all the details about the C++ min() function.

### C++ min() Function

The C++ min() function is a pre-defined function in the C++ library. It is defined in the *algorithm* header of the C++ library. It returns the minimum element from all the elements passed into this function as a parameter. If two minimum elements are equal, it returns the first element.

### 3 Versions of C++ min() Function

#### Version 1: For comparing elements using "< ".

It will compare the two elements passed as the arguments and will return the minimum of the two elements. If both elements are equal, then it will return the first one.

#### Syntax

#### C++ Implementation

**Output**

#### Time Complexity

#### Space Complexity

**Time complexity** : O ( 1 ) O(1) O ( 1 )

**Auxiliary Space** : O ( 1 ) O(1) O ( 1 )

#### Version 2: For comparing elements using a pre-defined function

It is also used for comparing the two elements passed as the arguments by using a binary function, which the programmer will define. It will return the minimum of the two elements, and if both are equal, it will return the first one.

#### Syntax

**Output**

#### Time Complexity

#### Space Complexity

**Time complexity** : O ( 1 ) O(1) O ( 1 )

**Auxiliary Space** : O ( 1 ) O(1) O ( 1 )

#### Version 3: For Finding Minimum Element in a List

It is used for comparing the list of elements passed as the arguments using a comparator function, which the programmer will define. It will return the minimum of all the elements, and if two or more smallest elements are present, it will return the first one.

#### Syntax

**Output**

#### Time Complexity

#### Space Complexity

**Time complexity** : O ( N ) O(N) O ( N )

**Auxiliary Space** : O ( 1 ) O(1) O ( 1 )

### Parameters of C++ min() Function

The C++ min() function accepts a maximum of 3 arguments, the details of which are given below.

* element1, element2*: these are the values to be compared.

**comp**: This is a binary function that accepts two values as arguments of type T and returns a value after converting it to bool. The value returned is true if the element passed as the first argument is less than the second, else it will return false.

### Return Value of C++ min() Function

The C++ min() function will return the minimum value from all the values passed in the function as an argument.

### Exceptions of C++ min() Function

If the invalid arguments are passed in the min() function, it can cause undefined behavior.

It will throw an error if any comparison throws any exception.

### How does the C++ min() Function work?

The min() function accepts two elements as an argument.

After that, it will compare the two elements with each other.

The element with the smaller value is returned by the min() function.

If the value of both elements is the same, then the min function returns the first element.

### Uses of C++ min() Function?

It is used to find the smaller value from the two values passed as an argument.

It is also used to find the smallest value from the list.

### Examples of C++ min() Function

#### Example 1:

In this example, we will see how the C++ min() function works for values of int data type.

**C++ Implementation**

**Output**

#### Example 2:

In this example, we will see how the C++ min() function works for values of float data type.

**C++ Implementation**

**Output**

#### Example 3:

In this example, we will see how the C++ min() function works for values of the char data type.

**C++ Implementation**

**Output**

#### Example 4:

This example shows how the C++ min() function works for values of double data types.

**C++ Implementation**

**Output**

#### Example 5:

In this example, we will see how the C++ min() function works for values of string data type.

**C++ Implementation**

**Output**

### Related Functions in C++

### Conclusion

In this quick tutorial, we have discussed the C++ min() function, and we can extract the following conclusions from the article.

The min() function is used to find the minimum element from all the elements passed as an argument.

The min() function compares two elements simultaneously to find the minimum element. If a comparator is passed, then it uses that to compare the two elements.

We should not pass any invalid arguments because if the invalid arguments are passed in the C++ min() function, then it can cause undefined behavior.

## Функции min/max/random

компилятор ругается на то что дескать "max это неопределенный идентификатор". так как написать эту функцию?

и ещё: хотел использовать функцию random написал (в другой программе не относящейся к первой проблеме)

компилятор пишет мол "слишком много аргументов в вызове функции" но ведь я ему только один аргумент дал, как может быть слишком много аргументов?

**5х5 random массив В главной диагонали найти min и поменять местами max массива**

4) 5х5 random массив. в главной диагонали найти min и поменять местами max массива. если одинаковые.

**Функции max min**

не могу написать функцию для вычисления такого рода. Даны натуральные числа k, n, m.

**min, max функции.**

Даны числа a(1), a(2), , a(2n). Вычислить: 1) max (a(1)+a(2n), a(2)+a(2n-1), , a(n)+a(n+1));и 2).

Сообщение от **MaxFX**

Для этой функции надо подключать не *stdlib.h*, а *algorithm*.

*Добавлено через 1 минуту*

Сообщение от **MaxFX**

всё это не сделало погоды, компилятор по прежнему не распознает эти функции. меня сбивает с толку что в учебнике по которому я учусь написано что нужно лишь подключить stdlib.h и написать функцию следуйщим образом:

видимо я что то упустил из виду раз у меня это не работает. не думаю что в учебнике такая конкретная опечатка может быть.

из ответа IrineK’а мало что понял. что такое "cout << " и "<< endl;" ?

кто нибудь кому не трудно, напишите пожалуйста программу которая принимала бы 2 числа, с помощью функции определяла какое число больше, и выводила на экран то число которое больше. я попробую на практическом примере разобраться

## Min and max basics

Finding the smaller and the larger of two values, how hard can it be, right?

## Introduction

To evaluate the capabilities of a programming language it’s practical to start by examining in detail just three functions: min , swap and linear search ( find ). Despite their presumed simplicity, it’s difficult, but important that they are done right. For example, the three functions contain the fundamentals for constructing sort , itself an important building block for many programs.

Here I’m going to focus mainly on min , a function that takes two arguments and returns the smallest of the two, and look at a C++ implementation. Essentially we’re going to implement std::min from the standard C++ library,

Here is a sample C++ implementation, with subtly different choices, mainly because the focus here is on what’s ideal, without any pressure to be backwards compatible.

The rest of the article is about how did we get there.

## Generic

The implementation of algorithms like min has to be generic.

Using a non-generic approach is repetitive as demonstrated below for int and double :

This approach might just about do for min , but it does not work for more complex algorithms. Formally it’s the N x M problem: given N data types and M algorithms we want to avoid having to write N x M implementations.

Using C++ templates, we defined min as a function template with a type T as a parameter:

This allows a generic solution that can be implemented once and then work with a variety of types like: int , double , other built-in types, std::string , std::vector , other containers, user defined types.

## Namespace

We want to be able to use min like this:

Now, if this example compiles, it’s likely that it uses std::min because of rules that will look for functions in the same namespace of the arguments, aka. argument dependent lookup (ADL).

To avoid ambiguity, we defined our min implementation in a namespace algs , and we’ll qualify the call explicitly:

## Arguments and return value

Arguments are passed by reference which has the advantage that larger types do not get copied unnecessarily.

Arguments are passed by const reference, which has the advantage that literals can also be used as arguments:

Another advantage of this declaration is that the type T is automatically deduced: most of the time does not need to be specified by the user.

However one disadvantage is that we can’t mutate the returned value, because there is no overload for non- const reference.

## Implementation — options

As for the implementation, we’ve got several options:

When the arguments are equal, option 1 returns b , the other options return a . Options 2, 3 and 4 differ in the exact operator used.

The canonical implementation is the equivalent of option 4.

If the arguments are equal, it should not matter which one is returned. However equal does not mean identical, and one can probe the address of the returned value to see which one is returned. We’ll come back to this later.

Also min does not exist in isolation, but in relationship with other algorithms, and that’s what clarifies what’s the most coherent implementation option.

## Relationship with other algorithms

First of all we have similar algorithms that differ by the value returned:

- max which returns the larger of two
- minmax which returns a pair (smallest first, larger second) out of two

When values are equal, it makes sense for min to return one, and for max to return the other, this leads to requiring that the canonical implementation for max does the equivalent of:

Note that the above is not what std::max does, because it’s standardised to do the wrong thing.

Then we have algorithms that operate on a sequence:

- min_element which returns an iterator to the smallest out of a sequence
- max_element which returns an iterator to the larger out of a sequence
- minmax_element returns a pair of the two out of a sequence

Then we algorithms that use the order to do sequence permutations:

- nth_element which sorts up to the n-th position ( min is a very basic version of this, getting just the smallest value)
- sort which sorts an entire sequence
- stable_sort which also sorts, but preserves the order of equal elements

It is the relationship with sort that makes < the implicit comparison choice. E.g. it has the advantage that the sequence will be sorted ascending, which is the natural order.

The stability property refers to preserving the order of equal elements. For sorting there are two different function because achieving stability comes there at an additional computational effort. If min (and max ) can have the stability property at no additional cost, we should not give that up lightly.

And finally we have versions of min :

- with two arguments: implicitly using < for comparisons
- with three arguments: adds an explicit comparison function
- with four arguments: adds a projection function that specifies what to compare

If you try to invoke the straight forward min with an unsuitable type you’ll get an error that basically follows the nesting of whatever the implementation happens to be:

## StrictTotallyOrdered

The version of min with two arguments uses < for comparison and has the requirement that the type T is StrictTotallyOrdered . That means that not only < is implemented, but also all the other comparisons, including equality are defined, and they work sanely e.g.: given arbitrary a and b , one an only one is true: a < b or a == b or a > b .

## Comparison

The version with three arguments adds an explicit comparison function. This version has relaxed requirements. The comparison can be weak. Unlike < , the counterpart is a equivalence relation, not equality. E.g. we can compare instances of person by age (instances that have different names, but same age are equivalent). It’s here that it does matter which one is returned out of two equivalent values.

## Projection

Projection is applied before using the values (passing them to the comparison function.

This allows a different way to compare by age :

In the implementation above std::invoke was used instead.

This allows a simpler call then the projection only takes a member variable:

## Less — function object

In the code above less is a struct and only it’s operator() is a function template. This choice is more similar to std::less<> which for backward compatibility reasons is a specialization for std::less for void .

Notice that the arguments T and U can be different types. min does not use this, but it’s useful for things like std::set<std::string> when we want to find using a literal string, so comparison is between a const std::string & and a const char * .

## std::min

(1,3) версии используют operator< для сравнения значений, (2,4) версии используют данную функцию сравнения comp .

#### Parameters

a, b | — | сравниваемые значения |

ilist | — | список инициализаторов со значениями для сравнения |

cmp | — | функция сравнения объект (т.е. объект , который удовлетворяет требованиям сравнения ) , который возвращает true если является a less than b . |

Подпись функции сравнения должна быть эквивалентна следующей:

bool cmp(const Type1 &a, const Type2 &b);

Хотя подпись не должна иметь const & , функция не должна изменять передаваемые ей объекты и должна иметь возможность принимать все значения типа (возможно, const) Type1 и Type2 независимо от категории значения (таким образом, Type1 & не допускается Кроме того, Type1 не является исключением, если для Type1 перемещение эквивалентно копии (начиная с C ++ 11)).

Типы Type1 и Type2 должны быть такими, чтобы объект типа T мог быть неявно преобразован в них обоих.

## Min and max basics

Finding the smaller and the larger of two values, how hard can it be, right?

## Introduction

To evaluate the capabilities of a programming language it’s practical to start by examining in detail just three functions: min , swap and linear search ( find ). Despite their presumed simplicity, it’s difficult, but important that they are done right. For example, the three functions contain the fundamentals for constructing sort , itself an important building block for many programs.

Here I’m going to focus mainly on min , a function that takes two arguments and returns the smallest of the two, and look at a C++ implementation. Essentially we’re going to implement std::min from the standard C++ library,

Here is a sample C++ implementation, with subtly different choices, mainly because the focus here is on what’s ideal, without any pressure to be backwards compatible.

The rest of the article is about how did we get there.

## Generic

The implementation of algorithms like min has to be generic.

Using a non-generic approach is repetitive as demonstrated below for int and double :

This approach might just about do for min , but it does not work for more complex algorithms. Formally it’s the N x M problem: given N data types and M algorithms we want to avoid having to write N x M implementations.

Using C++ templates, we defined min as a function template with a type T as a parameter:

This allows a generic solution that can be implemented once and then work with a variety of types like: int , double , other built-in types, std::string , std::vector , other containers, user defined types.

## Namespace

We want to be able to use min like this:

Now, if this example compiles, it’s likely that it uses std::min because of rules that will look for functions in the same namespace of the arguments, aka. argument dependent lookup (ADL).

To avoid ambiguity, we defined our min implementation in a namespace algs , and we’ll qualify the call explicitly:

## Arguments and return value

Arguments are passed by reference which has the advantage that larger types do not get copied unnecessarily.

Arguments are passed by const reference, which has the advantage that literals can also be used as arguments:

Another advantage of this declaration is that the type T is automatically deduced: most of the time does not need to be specified by the user.

However one disadvantage is that we can’t mutate the returned value, because there is no overload for non- const reference.

## Implementation — options

As for the implementation, we’ve got several options:

When the arguments are equal, option 1 returns b , the other options return a . Options 2, 3 and 4 differ in the exact operator used.

The canonical implementation is the equivalent of option 4.

If the arguments are equal, it should not matter which one is returned. However equal does not mean identical, and one can probe the address of the returned value to see which one is returned. We’ll come back to this later.

Also min does not exist in isolation, but in relationship with other algorithms, and that’s what clarifies what’s the most coherent implementation option.

## Relationship with other algorithms

First of all we have similar algorithms that differ by the value returned:

- max which returns the larger of two
- minmax which returns a pair (smallest first, larger second) out of two

When values are equal, it makes sense for min to return one, and for max to return the other, this leads to requiring that the canonical implementation for max does the equivalent of:

Note that the above is not what std::max does, because it’s standardised to do the wrong thing.

Then we have algorithms that operate on a sequence:

- min_element which returns an iterator to the smallest out of a sequence
- max_element which returns an iterator to the larger out of a sequence
- minmax_element returns a pair of the two out of a sequence

Then we algorithms that use the order to do sequence permutations:

- nth_element which sorts up to the n-th position ( min is a very basic version of this, getting just the smallest value)
- sort which sorts an entire sequence
- stable_sort which also sorts, but preserves the order of equal elements

It is the relationship with sort that makes < the implicit comparison choice. E.g. it has the advantage that the sequence will be sorted ascending, which is the natural order.

The stability property refers to preserving the order of equal elements. For sorting there are two different function because achieving stability comes there at an additional computational effort. If min (and max ) can have the stability property at no additional cost, we should not give that up lightly.

And finally we have versions of min :

- with two arguments: implicitly using < for comparisons
- with three arguments: adds an explicit comparison function
- with four arguments: adds a projection function that specifies what to compare

If you try to invoke the straight forward min with an unsuitable type you’ll get an error that basically follows the nesting of whatever the implementation happens to be:

## StrictTotallyOrdered

The version of min with two arguments uses < for comparison and has the requirement that the type T is StrictTotallyOrdered . That means that not only < is implemented, but also all the other comparisons, including equality are defined, and they work sanely e.g.: given arbitrary a and b , one an only one is true: a < b or a == b or a > b .

## Comparison

The version with three arguments adds an explicit comparison function. This version has relaxed requirements. The comparison can be weak. Unlike < , the counterpart is a equivalence relation, not equality. E.g. we can compare instances of person by age (instances that have different names, but same age are equivalent). It’s here that it does matter which one is returned out of two equivalent values.

## Projection

Projection is applied before using the values (passing them to the comparison function.

This allows a different way to compare by age :

In the implementation above std::invoke was used instead.

This allows a simpler call then the projection only takes a member variable:

## Less — function object

In the code above less is a struct and only it’s operator() is a function template. This choice is more similar to std::less<> which for backward compatibility reasons is a specialization for std::less for void .

Notice that the arguments T and U can be different types. min does not use this, but it’s useful for things like std::set<std::string> when we want to find using a literal string, so comparison is between a const std::string & and a const char * .

## C++ min() Function

There are many inbuilt comparator functions in C++ that compare two or more values with each other. One such function is the C++ min() function. The article contains all the details about the C++ min() function.

### C++ min() Function

The C++ min() function is a pre-defined function in the C++ library. It is defined in the *algorithm* header of the C++ library. It returns the minimum element from all the elements passed into this function as a parameter. If two minimum elements are equal, it returns the first element.

### 3 Versions of C++ min() Function

#### Version 1: For comparing elements using "< ".

It will compare the two elements passed as the arguments and will return the minimum of the two elements. If both elements are equal, then it will return the first one.

#### Syntax

#### C++ Implementation

**Output**

#### Time Complexity

#### Space Complexity

**Time complexity** : O ( 1 ) O(1) O ( 1 )

**Auxiliary Space** : O ( 1 ) O(1) O ( 1 )

#### Version 2: For comparing elements using a pre-defined function

It is also used for comparing the two elements passed as the arguments by using a binary function, which the programmer will define. It will return the minimum of the two elements, and if both are equal, it will return the first one.

#### Syntax

**Output**

#### Time Complexity

#### Space Complexity

**Time complexity** : O ( 1 ) O(1) O ( 1 )

**Auxiliary Space** : O ( 1 ) O(1) O ( 1 )

#### Version 3: For Finding Minimum Element in a List

It is used for comparing the list of elements passed as the arguments using a comparator function, which the programmer will define. It will return the minimum of all the elements, and if two or more smallest elements are present, it will return the first one.

#### Syntax

**Output**

#### Time Complexity

#### Space Complexity

**Time complexity** : O ( N ) O(N) O ( N )

**Auxiliary Space** : O ( 1 ) O(1) O ( 1 )

### Parameters of C++ min() Function

The C++ min() function accepts a maximum of 3 arguments, the details of which are given below.

* element1, element2*: these are the values to be compared.

**comp**: This is a binary function that accepts two values as arguments of type T and returns a value after converting it to bool. The value returned is true if the element passed as the first argument is less than the second, else it will return false.

### Return Value of C++ min() Function

The C++ min() function will return the minimum value from all the values passed in the function as an argument.

### Exceptions of C++ min() Function

If the invalid arguments are passed in the min() function, it can cause undefined behavior.

It will throw an error if any comparison throws any exception.

### How does the C++ min() Function work?

The min() function accepts two elements as an argument.

After that, it will compare the two elements with each other.

The element with the smaller value is returned by the min() function.

If the value of both elements is the same, then the min function returns the first element.

### Uses of C++ min() Function?

It is used to find the smaller value from the two values passed as an argument.

It is also used to find the smallest value from the list.

### Examples of C++ min() Function

#### Example 1:

In this example, we will see how the C++ min() function works for values of int data type.

**C++ Implementation**

**Output**

#### Example 2:

In this example, we will see how the C++ min() function works for values of float data type.

**C++ Implementation**

**Output**

#### Example 3:

In this example, we will see how the C++ min() function works for values of the char data type.

**C++ Implementation**

**Output**

#### Example 4:

This example shows how the C++ min() function works for values of double data types.

**C++ Implementation**

**Output**

#### Example 5:

In this example, we will see how the C++ min() function works for values of string data type.

**C++ Implementation**

**Output**

### Related Functions in C++

### Conclusion

In this quick tutorial, we have discussed the C++ min() function, and we can extract the following conclusions from the article.

The min() function is used to find the minimum element from all the elements passed as an argument.

The min() function compares two elements simultaneously to find the minimum element. If a comparator is passed, then it uses that to compare the two elements.

We should not pass any invalid arguments because if the invalid arguments are passed in the C++ min() function, then it can cause undefined behavior.

## std::min in C++

**std::min** is defined in the header file <algorithm> and is used to find out the smallest of the number passed to it. It returns the first of them, if there are more than one. **It can be used in following 3 manners:**

- It compares the two numbers passed in its arguments and
**returns the smaller of the two**, and if both are equal, then it returns the first one. - It can also compare the two numbers using a
**binary function**, which is defined by the user, and then passed as argument in std::min(). - It is also useful if we want to find the
**smallest element in a given list**, and it returns the first one if there are more than one present in the list.

**The three versions are as defined below:**

- For comparing elements using
**<**:

Syntax:

**Time complexity :-** O(1)**Auxiliary Space :-** O(1)

2. **For comparing elements using a pre-defined function:**

Syntax:

**Time complexity :-** O(1)**Auxiliary Space:-** O(1)

3. **For finding the minimum element in a list:**

Syntax:

**Time complexity :-** O(n)**Auxiliary Space :-** O(1)

## min function in C

We are ready to get our hands on the first example of the min function in the C programming language. Let’s create a file with any name but a .c extension. Start including the header files in it. We have used <stdio.h >header file. In a C program, the <stdio.h >header file is used to conduct Basic or Standard Input/output functions. In another way, we can obtain Input/output capabilities in our program by including this header file at the start of the program.

Then we have our main () function. Every program revolves around it. It is a mandatory requirement to have a main() function in every program. The main() function is not required to perform anything other than exist within your C source code. Finally, it comprises instructions that direct the computer to perform the task that your program was created to perform. However, nothing is made mandatory of you.

Now we have declared three variables of integer data type title “a”, “b”, and “minimum”. Then we have a printf() function that will prompt the user to enter their desired number at run time. These values will be kept in the “a” and “b” variables. Then we have to use the scanf() function. In the C programming language, the scanf function is being used to recognize characters or any other input from the developer. Scanf is a built-in function that is already defined in the library file in any C package.

We have called a min() function in the main() program. And specified its condition in the separately stated min() function, as seen in the screenshot. Returning 0 indicates that the program completed effectively and accomplished what it was designed to do

Now execute the above-attached code in the GCC compiler. The black screen is presented and asks the user to enter the two desired numbers.

Let’s suppose the user has entered 12 and 34 numbers; the program will choose the minimum number by running the min function. The output is correct as it can be verified from the output screen

### Example 2

This example will use the min() function and the max() function, so it is a bit complex. Before going through this one, carefully understand the above-stated example.

Let’s generate a file with any title but a .c extension. Start including the header files in it. We have used <stdio.h >header file. In a C program, the <stdio.h >header file is used to conduct Simple or Standard Input/output functions. To put it another way, we can obtain Input/output capabilities in our program by including this header file at the start of the program.

Now we have declared five variables of integer data type title “x “j”, “n”, “maximum”, and “minimum”. “x” is an array. Then we have a printf() function that will prompt the user to enter the size of the array at run time. Then we have to use the scanf() function. In the C programming language, the scanf function is being used to identify characters or any other input from the user. Scanf is a built-in function that is already defined in the library file in any C package. Again we have a printf() function that will prompt the user to enter the elements of the array at run time.

Now we have used the “for” loop. In the C programming language, the for loop is used to repeat statements or parts of a program repeatedly. This enables them to write code once and then reuse it as needed, increasing the probability that the program will function as planned. We have applied the condition to calculate the minimum and maximum values from the user’s elements. Again we have two printf() statements that will display the minimum and a maximum value of the array on the screen. “Return 0” indicates that the program completed effectively and accomplished what it was intended to do.

Now execute the above-attached code in the GCC compiler. The black screen is presented and asks the user to enter the size and elements in the array.

Let’s suppose the user has entered the size as “4” and the values as 0, 7, 3, and 7 . the program will choose the minimum and maximum value. The output is correct as it can be verified from the output screen

### Conclusion

This article was all about the minimum function in the C programming language. However, as a bonus point, we have also utilized the max() function in the example. The examples mentioned in this guide have been clarified in detail. I hope the user will have no trouble while using the min() function in the C language.