// (1) size_type count(const typename object_t::key_type& key) const; // (2) template<typename KeyType> size_type count(KeyType&& key) const; // (3) template<typename T> size_type count(T) const = delete;
key. If ObjectType is the default std::map type, the return value will always be 0 (key was not found) or 1 (key was found).KeyType is comparable with #!cpp typename object_t::key_type and #!cpp typename object_comparator_t::is_transparent denotes a type.T is an integral type and is declared as deleted, so that a call with an integer key (for example, #!cpp j.count(0)) fails to compile. Otherwise, the integer literal 0 would convert to a null #!cpp const char* and, from there, to the key type, causing undefined behavior at runtime.KeyType : A type for an object key other than json_pointer that is comparable with string_t using object_comparator_t. This can also be a string view (C++17).
key (in) : key value of the element to count.
Number of elements with key key. If the JSON value is not an object, the return value will be 0.
Strong exception safety: if an exception occurs, the original value stays intact.
Logarithmic in the size of the JSON object.
0 when executed on a JSON type that is not an object.#!cpp count(0)) does not compile: such an argument would otherwise implicitly convert to a null #!cpp const char* and, from there, cause undefined behavior when constructing a #!cpp std::string for the object key. To check for an array element instead, use at, operator[], or compare against size.??? example “Example: (1) count number of elements”
The example shows how `count()` is used.
```cpp
#include <iostream>
#include <nlohmann/json.hpp>
using json = nlohmann::json;
int main()
{
// create a JSON object
json j_object = {{"one", 1}, {"two", 2}};
// call count()
auto count_two = j_object.count("two");
auto count_three = j_object.count("three");
// print values
std::cout << "number of elements with key \"two\": " << count_two << '\n';
std::cout << "number of elements with key \"three\": " << count_three << '\n';
}
```
Output:
```json
number of elements with key "two": 1
number of elements with key "three": 0
```
??? example “Example: (2) count number of elements using string_view”
The example shows how `count()` is used.
```cpp
#include <iostream>
#include <string_view>
#include <nlohmann/json.hpp>
using namespace std::string_view_literals;
using json = nlohmann::json;
int main()
{
// create a JSON object
json j_object = {{"one", 1}, {"two", 2}};
// call count()
auto count_two = j_object.count("two"sv);
auto count_three = j_object.count("three"sv);
// print values
std::cout << "number of elements with key \"two\": " << count_two << '\n';
std::cout << "number of elements with key \"three\": " << count_three << '\n';
}
```
Output:
```json
number of elements with key "two": 1
number of elements with key "three": 0
```
key type to KeyType&& in version 3.11.0. Fixed in version 3.13.0 to consistently accept std::string_view-convertible keys, as already supported by operator[], at, value, and other lookup functions.