---
name: "bsearch"
section: "3"
platform: "freebsd"
package: "base"
version: "16.0-CURRENT-20261027-61c70dc16a79"
release: "FreeBSD 16.0-CURRENT (2026-10-27)"
platforms: ["linux", "freebsd", "macos"]
url: "https://new.carta.tech/bsearch"
---

# bsearch(3)

binary search of a sorted table

## NAME

**bsearch**, **bsearch\_b**, **bsearch\_s** – binary search of a sorted table

## LIBRARY

Standard C Library (libc, -lc)

## SYNOPSIS

**#include \<stdlib.h\>**

*QVoid \**\

**bsearch**(*const void \*key*, *QVoid \*base*, *size\_t nmemb*, *size\_t size*, *int (\*compar) (const void \*, const void \*)*);

*QVoid \**\

**bsearch\_b**(*const void \*key*, *QVoid \*base*, *size\_t nmemb*, *size\_t size*, *int (^compar) (const void \*, const void \*)*);

**#define \_\_STDC\_WANT\_LIB\_EXT1\_\_ 1**

*QVoid \**\

**bsearch\_s**(*const void \*key*, *QVoid \*base*, *rsize\_t nmemb*, *rsize\_t size*, *int (\*compar) (const void \*, const void \*, void \*)*, *void \*context*);

## DESCRIPTION

The **bsearch**() function searches an array of *nmemb* objects, the initial member of which is pointed to by *base*, for a member that matches the object pointed to by *key*. The size of each member of the array is specified by *size*.

The contents of the array should be in ascending sorted order according to the comparison function referenced by *compar*. The *compar* routine is expected to have two arguments which point to the *key* object and to an array member, in that order, and should return an integer less than, equal to, or greater than zero if the *key* object is found, respectively, to be less than, to match, or be greater than the array member. See the *int\_compare* sample function in [qsort(3)](/qsort/3.md) for a comparison function that is also compatible with **bsearch**().

The **bsearch\_b**() function behaves identically to **bsearch**(), except the callback *compar* takes a block pointer instead of a function pointer.

The **bsearch\_s**() function behaves identically to **bsearch**(), except the callback *compar* is called with a third argument, *context*, which is passed through from the caller. Runtime-constraint violation occurs if:

- *nmemb* or *size* is greater than RSIZE\_MAX

- *nmemb* is not zero and any of *key*, *base*, or *compar* is a null pointer

On a runtime-constraint violation, the runtime-constraint handler is invoked, **bsearch\_s**() does not search the array, and a null pointer is returned. Note that the handler is called before **bsearch\_s**() returns, and the handler function might not return. If *nmemb* is zero, the comparison function is not called, no match is found, and *key*, *base*, and *compar* may be null pointers.

## RETURN VALUES

The **bsearch**(), **bsearch\_b**(), and **bsearch\_s**() functions return a pointer to a matching member of the array, or a null pointer if no match is found. **bsearch\_s**() also returns a null pointer if there is a runtime-constraint violation. If two members compare as equal, which member is matched is unspecified.

## EXAMPLES

A sample program that searches people by age in a sorted array:

```
#include <assert.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
struct person {
	const char 	*name;
	int 		age;
};
static int
compare(const void *a, const void *b)
{
	const int *age;
	const struct person *person;
	age = a;
	person = b;
	return (*age - person->age);
}
int
main(void)
{
	struct person *friend;
	int age;
	/* Sorted array */
	const struct person friends[] = {
		{ "paul", 22 },
		{ "anne", 25 },
		{ "fred", 25 },
		{ "mary", 27 },
		{ "mark", 35 },
		{ "bill", 50 }
	};
	const size_t len = sizeof(friends) / sizeof(friends[0]);
	age = 22;
	friend = bsearch(&age, friends, len, sizeof(friends[0]), compare);
	assert(strcmp(friend->name, "paul") == 0);
	printf("name: %s\nage: %d\n", friend->name, friend->age);
	age = 25;
	friend = bsearch(&age, friends, len, sizeof(friends[0]), compare);
	/*
	 * For multiple elements with the same key, it is implementation
	 * defined which will be returned
	 */
	assert(strcmp(friend->name, "fred") == 0 ||
	    strcmp(friend->name, "anne") == 0);
	printf("name: %s\nage: %d\n", friend->name, friend->age);
	age = 30;
	friend = bsearch(&age, friends, len, sizeof(friends[0]), compare);
	assert(friend == NULL);
	printf("friend aged 30 not found\n");
}
```

## SEE ALSO

[db(3)](/db/3.md), [lsearch(3)](/lsearch/3.md), [qsort(3)](/qsort/3.md), [set\_constraint\_handler\_s(3)](/set_constraint_handler_s/3.md)

## STANDARDS

The **bsearch**() function conforms to ISO/IEC 9899:2024 (“ISO C23”), where it is specified as a qualifier-preserving function.

The **bsearch\_s**() function conforms to ISO/IEC 9899:2024 (“ISO C23”), section K.3.6.3.2. Like **bsearch**(), it is specified as a qualifier-preserving function.

## HISTORY

The **bsearch**(), initially specified in the -svid1, first appeared in AT&T System V Release 2 UNIX and later in 4.3BSD. It was first standardized in ISO/IEC 9899:1990 (“ISO C90”).

The **bsearch\_b**() function first appeared in Mac OS X and was later added to FreeBSD 11.0 as an extension.

The **bsearch\_s**() function first appeared in FreeBSD 16.0. It was first standardized in ISO/IEC 9899:2011 (“ISO C11”).