[#absl-operator_eq-03e9]
= xref:absl.adoc[absl]::operator&equals;&equals;
:relfileprefix: ../
:mrdocs:

Equality operators

== Synopses

Declared in `&lt;absl&sol;status&sol;status&period;h&gt;`

Compares two parameter sets for equality&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:absl/operator_eq-030.adoc[operator&equals;&equals;](
    xref:absl/exponential_distribution/param_type.adoc[param&lowbar;type] const& a,
    xref:absl/exponential_distribution/param_type.adoc[param&lowbar;type] const& b);
----

[.small]#xref:absl/operator_eq-030.adoc[_» more&period;&period;&period;_]#

Compares two parameter sets for equality&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:absl/operator_eq-0bb.adoc[operator&equals;&equals;](
    xref:absl/uniform_real_distribution/param_type.adoc[param&lowbar;type] const& a,
    xref:absl/uniform_real_distribution/param_type.adoc[param&lowbar;type] const& b);
----

[.small]#xref:absl/operator_eq-0bb.adoc[_» more&period;&period;&period;_]#

Compares two distributions for equality&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:absl/operator_eq-0ad.adoc[operator&equals;&equals;](
    xref:absl/zipf_distribution.adoc[zipf&lowbar;distribution] const& a,
    xref:absl/zipf_distribution.adoc[zipf&lowbar;distribution] const& b);
----

[.small]#xref:absl/operator_eq-0ad.adoc[_» more&period;&period;&period;_]#

Compares two parameter sets for equality&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:absl/operator_eq-041.adoc[operator&equals;&equals;](
    xref:absl/zipf_distribution/param_type.adoc[param&lowbar;type] const& a,
    xref:absl/zipf_distribution/param_type.adoc[param&lowbar;type] const& b);
----

[.small]#xref:absl/operator_eq-041.adoc[_» more&period;&period;&period;_]#

Compares two distributions for equality&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:absl/operator_eq-055.adoc[operator&equals;&equals;](
    xref:absl/uniform_int_distribution.adoc[uniform&lowbar;int&lowbar;distribution] const& a,
    xref:absl/uniform_int_distribution.adoc[uniform&lowbar;int&lowbar;distribution] const& b);
----

[.small]#xref:absl/operator_eq-055.adoc[_» more&period;&period;&period;_]#

Compares two parameter sets for equality&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:absl/operator_eq-06c.adoc[operator&equals;&equals;](
    xref:absl/uniform_int_distribution/param_type.adoc[param&lowbar;type] const& a,
    xref:absl/uniform_int_distribution/param_type.adoc[param&lowbar;type] const& b);
----

[.small]#xref:absl/operator_eq-06c.adoc[_» more&period;&period;&period;_]#

Compares two distributions for equality&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:absl/operator_eq-021.adoc[operator&equals;&equals;](
    xref:absl/poisson_distribution.adoc[poisson&lowbar;distribution] const& a,
    xref:absl/poisson_distribution.adoc[poisson&lowbar;distribution] const& b);
----

[.small]#xref:absl/operator_eq-021.adoc[_» more&period;&period;&period;_]#

Compares two parameter sets for equality&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:absl/operator_eq-0d8.adoc[operator&equals;&equals;](
    xref:absl/poisson_distribution/param_type.adoc[param&lowbar;type] const& a,
    xref:absl/poisson_distribution/param_type.adoc[param&lowbar;type] const& b);
----

[.small]#xref:absl/operator_eq-0d8.adoc[_» more&period;&period;&period;_]#

Compares two distributions for equality&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:absl/operator_eq-038.adoc[operator&equals;&equals;](
    xref:absl/bernoulli_distribution.adoc[bernoulli&lowbar;distribution] const& d1,
    xref:absl/bernoulli_distribution.adoc[bernoulli&lowbar;distribution] const& d2);
----

[.small]#xref:absl/operator_eq-038.adoc[_» more&period;&period;&period;_]#

Compares two parameter sets for equality&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:absl/operator_eq-0530.adoc[operator&equals;&equals;](
    xref:absl/bernoulli_distribution/param_type.adoc[param&lowbar;type] const& p1,
    xref:absl/bernoulli_distribution/param_type.adoc[param&lowbar;type] const& p2);
----

[.small]#xref:absl/operator_eq-0530.adoc[_» more&period;&period;&period;_]#

Compares two distributions for equality&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:absl/operator_eq-0af.adoc[operator&equals;&equals;](
    xref:absl/beta_distribution.adoc[beta&lowbar;distribution] const& a,
    xref:absl/beta_distribution.adoc[beta&lowbar;distribution] const& b);
----

[.small]#xref:absl/operator_eq-0af.adoc[_» more&period;&period;&period;_]#

Compares two parameter sets for equality&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:absl/operator_eq-037.adoc[operator&equals;&equals;](
    xref:absl/beta_distribution/param_type.adoc[param&lowbar;type] const& a,
    xref:absl/beta_distribution/param_type.adoc[param&lowbar;type] const& b);
----

[.small]#xref:absl/operator_eq-037.adoc[_» more&period;&period;&period;_]#

Compares two distributions for equality&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:absl/operator_eq-08d6.adoc[operator&equals;&equals;](
    xref:absl/exponential_distribution.adoc[exponential&lowbar;distribution] const& a,
    xref:absl/exponential_distribution.adoc[exponential&lowbar;distribution] const& b);
----

[.small]#xref:absl/operator_eq-08d6.adoc[_» more&period;&period;&period;_]#

Compares two distributions for equality&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:absl/operator_eq-086.adoc[operator&equals;&equals;](
    xref:absl/uniform_real_distribution.adoc[uniform&lowbar;real&lowbar;distribution] const& a,
    xref:absl/uniform_real_distribution.adoc[uniform&lowbar;real&lowbar;distribution] const& b);
----

[.small]#xref:absl/operator_eq-086.adoc[_» more&period;&period;&period;_]#

Compares two distributions for equality&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:absl/operator_eq-0e5f.adoc[operator&equals;&equals;](
    xref:absl/gaussian_distribution.adoc[gaussian&lowbar;distribution] const& a,
    xref:absl/gaussian_distribution.adoc[gaussian&lowbar;distribution] const& b);
----

[.small]#xref:absl/operator_eq-0e5f.adoc[_» more&period;&period;&period;_]#

Compares two parameter sets for equality&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:absl/operator_eq-00c.adoc[operator&equals;&equals;](
    xref:absl/gaussian_distribution/param_type.adoc[param&lowbar;type] const& a,
    xref:absl/gaussian_distribution/param_type.adoc[param&lowbar;type] const& b);
----

[.small]#xref:absl/operator_eq-00c.adoc[_» more&period;&period;&period;_]#

Compares two distributions for equality&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:absl/operator_eq-09.adoc[operator&equals;&equals;](
    xref:absl/log_uniform_int_distribution.adoc[log&lowbar;uniform&lowbar;int&lowbar;distribution] const& a,
    xref:absl/log_uniform_int_distribution.adoc[log&lowbar;uniform&lowbar;int&lowbar;distribution] const& b);
----

[.small]#xref:absl/operator_eq-09.adoc[_» more&period;&period;&period;_]#

Compares two parameter sets for equality&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:absl/operator_eq-03e8.adoc[operator&equals;&equals;](
    xref:absl/log_uniform_int_distribution/param_type.adoc[param&lowbar;type] const& a,
    xref:absl/log_uniform_int_distribution/param_type.adoc[param&lowbar;type] const& b);
----

[.small]#xref:absl/operator_eq-03e8.adoc[_» more&period;&period;&period;_]#

Compares two distributions for equality&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:absl/operator_eq-08c.adoc[operator&equals;&equals;](
    xref:absl/discrete_distribution.adoc[discrete&lowbar;distribution] const& a,
    xref:absl/discrete_distribution.adoc[discrete&lowbar;distribution] const& b);
----

[.small]#xref:absl/operator_eq-08c.adoc[_» more&period;&period;&period;_]#

Compares two parameter sets for equality&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:absl/operator_eq-0f6.adoc[operator&equals;&equals;](
    xref:absl/discrete_distribution/param_type.adoc[param&lowbar;type] const& a,
    xref:absl/discrete_distribution/param_type.adoc[param&lowbar;type] const& b);
----

[.small]#xref:absl/operator_eq-0f6.adoc[_» more&period;&period;&period;_]#

Compares two spans for element&hyphen;wise equality&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:absl/operator_eq-0b9.adoc[operator&equals;&equals;](
    xref:absl/AnySpan.adoc[AnySpan] a,
    xref:absl/AnySpan.adoc[AnySpan] b);
----

[.small]#xref:absl/operator_eq-0b9.adoc[_» more&period;&period;&period;_]#

Compares two const spans for element&hyphen;wise equality&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:absl/operator_eq-029.adoc[operator&equals;&equals;](
    xref:absl/AnySpan.adoc[AnySpan&lt;T const&gt;] a,
    xref:absl/AnySpan.adoc[AnySpan&lt;T const&gt;] b);
----

[.small]#xref:absl/operator_eq-029.adoc[_» more&period;&period;&period;_]#

Tests whether two iterators refer to the same position&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:absl/operator_eq-0f3.adoc[operator&equals;&equals;](
    Iter const& a,
    Iter const& b);
----

[.small]#xref:absl/operator_eq-0f3.adoc[_» more&period;&period;&period;_]#

Returns true if `a` and `b` refer to the same element&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:absl/operator_eq-053a.adoc[operator&equals;&equals;](
    xref:absl/chunked_queue.adoc[iterator&lowbar;common] const& a,
    xref:absl/chunked_queue.adoc[iterator&lowbar;common] const& b);
----

[.small]#xref:absl/operator_eq-053a.adoc[_» more&period;&period;&period;_]#

Returns whether two maps contain the same key&sol;value pairs&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:absl/operator_eq-040.adoc[operator&equals;&equals;](
    xref:absl/linked_hash_map.adoc[linked&lowbar;hash&lowbar;map] const& a,
    xref:absl/linked_hash_map.adoc[linked&lowbar;hash&lowbar;map] const& b);
----

[.small]#xref:absl/operator_eq-040.adoc[_» more&period;&period;&period;_]#

Returns whether two sets contain the same elements&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:absl/operator_eq-08e.adoc[operator&equals;&equals;](
    xref:absl/linked_hash_set.adoc[linked&lowbar;hash&lowbar;set] const& a,
    xref:absl/linked_hash_set.adoc[linked&lowbar;hash&lowbar;set] const& b);
----

[.small]#xref:absl/operator_eq-08e.adoc[_» more&period;&period;&period;_]#

Returns whether two fixed arrays are elementwise equal&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:absl/operator_eq-0c2.adoc[operator&equals;&equals;](
    xref:absl/FixedArray.adoc[FixedArray] const& lhs,
    xref:absl/FixedArray.adoc[FixedArray] const& rhs);
----

[.small]#xref:absl/operator_eq-0c2.adoc[_» more&period;&period;&period;_]#

Compares two spans for element&hyphen;wise equality&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;typename T&gt;
constexpr
bool
xref:absl/operator_eq-02b.adoc[operator&equals;&equals;](
    xref:absl/Span.adoc[Span&lt;T const&gt;] a,
    xref:absl/Span.adoc[Span&lt;T&gt;] b);
----

[.small]#xref:absl/operator_eq-02b.adoc[_» more&period;&period;&period;_]#

Compares two spans for element&hyphen;wise equality&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;typename T&gt;
constexpr
bool
xref:absl/operator_eq-0d6.adoc[operator&equals;&equals;](
    xref:absl/Span.adoc[Span&lt;T&gt;] a,
    xref:absl/Span.adoc[Span&lt;T const&gt;] b);
----

[.small]#xref:absl/operator_eq-0d6.adoc[_» more&period;&period;&period;_]#

Compares a container to a span for element&hyphen;wise equality&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    typename T,
    typename U,
    typename = span&lowbar;internal::EnableIfConvertibleTo&lt;U, absl::Span&lt;T const&gt;&gt;&gt;
constexpr
bool
xref:absl/operator_eq-0ff.adoc[operator&equals;&equals;](
    U const& a,
    xref:absl/Span.adoc[Span&lt;T&gt;] b);
----

[.small]#xref:absl/operator_eq-0ff.adoc[_» more&period;&period;&period;_]#

Compares a span to a container for element&hyphen;wise equality&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    typename T,
    typename U,
    typename = span&lowbar;internal::EnableIfConvertibleTo&lt;U, absl::Span&lt;T const&gt;&gt;&gt;
constexpr
bool
xref:absl/operator_eq-0c1.adoc[operator&equals;&equals;](
    xref:absl/Span.adoc[Span&lt;T&gt;] a,
    U const& b);
----

[.small]#xref:absl/operator_eq-0c1.adoc[_» more&period;&period;&period;_]#

Returns whether two times are equal&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
constexpr
bool
xref:absl/operator_eq-08d3.adoc[operator&equals;&equals;](
    xref:absl/Time.adoc[Time] lhs,
    xref:absl/Time.adoc[Time] rhs);
----

[.small]#xref:absl/operator_eq-08d3.adoc[_» more&period;&period;&period;_]#

Returns whether two time zones are equal&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:absl/operator_eq-0dc.adoc[operator&equals;&equals;](
    xref:absl/TimeZone.adoc[TimeZone] a,
    xref:absl/TimeZone.adoc[TimeZone] b);
----

[.small]#xref:absl/operator_eq-0dc.adoc[_» more&period;&period;&period;_]#

Returns whether two durations are equal&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
constexpr
bool
xref:absl/operator_eq-023.adoc[operator&equals;&equals;](
    xref:absl/Duration.adoc[Duration] lhs,
    xref:absl/Duration.adoc[Duration] rhs);
----

[.small]#xref:absl/operator_eq-023.adoc[_» more&period;&period;&period;_]#

Returns `true` if `f` is empty&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:absl/operator_eq-0ec.adoc[operator&equals;&equals;](
    std::nullptr&lowbar;t unused,
    xref:absl/AnyInvocable.adoc[AnyInvocable] const& f) noexcept;
----

[.small]#xref:absl/operator_eq-0ec.adoc[_» more&period;&period;&period;_]#

Returns `true` if `f` is empty&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:absl/operator_eq-0e9.adoc[operator&equals;&equals;](
    xref:absl/AnyInvocable.adoc[AnyInvocable] const& f,
    std::nullptr&lowbar;t unused) noexcept;
----

[.small]#xref:absl/operator_eq-0e9.adoc[_» more&period;&period;&period;_]#

Determines whether `lhs` and `rhs` are equal&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
constexpr
bool
xref:absl/operator_eq-0db.adoc[operator&equals;&equals;](
    xref:absl/uint128.adoc[uint128] lhs,
    xref:absl/uint128.adoc[uint128] rhs);
----

[.small]#xref:absl/operator_eq-0db.adoc[_» more&period;&period;&period;_]#

Tests for value&hyphen;equality of two inlined vectors&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    typename T,
    size&lowbar;t N,
    typename A&gt;
bool
xref:absl/operator_eq-0df.adoc[operator&equals;&equals;](
    xref:absl/InlinedVector.adoc[absl::InlinedVector&lt;T, N, A&gt;] const& a,
    xref:absl/InlinedVector.adoc[absl::InlinedVector&lt;T, N, A&gt;] const& b);
----

[.small]#xref:absl/operator_eq-0df.adoc[_» more&period;&period;&period;_]#

Compare two CRC32C values for equality&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:absl/operator_eq-0e53.adoc[operator&equals;&equals;](
    xref:absl/crc32c_t.adoc[crc32c&lowbar;t] lhs,
    xref:absl/crc32c_t.adoc[crc32c&lowbar;t] rhs);
----

[.small]#xref:absl/operator_eq-0e53.adoc[_» more&period;&period;&period;_]#

Compares two spans for element&hyphen;wise equality&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;typename T&gt;
constexpr
bool
xref:absl/operator_eq-084.adoc[operator&equals;&equals;](
    xref:absl/Span.adoc[Span&lt;T&gt;] a,
    xref:absl/Span.adoc[Span&lt;T&gt;] b);
----

[.small]#xref:absl/operator_eq-084.adoc[_» more&period;&period;&period;_]#

Compares a Cord with string data for equality&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:absl/operator_eq-073.adoc[operator&equals;&equals;](
    xref:absl/Cord.adoc[Cord] const& lhs,
    std::string&lowbar;view rhs);
----

[.small]#xref:absl/operator_eq-073.adoc[_» more&period;&period;&period;_]#

Compares two Cords for equality&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:absl/operator_eq-0f7.adoc[operator&equals;&equals;](
    xref:absl/Cord.adoc[Cord] const& lhs,
    xref:absl/Cord.adoc[Cord] const& rhs);
----

[.small]#xref:absl/operator_eq-0f7.adoc[_» more&period;&period;&period;_]#

Compares string data with a Cord for equality&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:absl/operator_eq-076.adoc[operator&equals;&equals;](
    std::string&lowbar;view x,
    xref:absl/Cord.adoc[Cord] const& y);
----

[.small]#xref:absl/operator_eq-076.adoc[_» more&period;&period;&period;_]#

Tests whether an `optional&lowbar;ref` is empty&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;typename T&gt;
constexpr
bool
xref:absl/operator_eq-06f.adoc[operator&equals;&equals;](
    xref:absl/optional_ref-0c.adoc[optional&lowbar;ref&lt;T&gt;] a,
    std::nullopt&lowbar;t b);
----

[.small]#xref:absl/operator_eq-06f.adoc[_» more&period;&period;&period;_]#

Tests whether an `optional&lowbar;ref` is empty&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;typename T&gt;
constexpr
bool
xref:absl/operator_eq-0ab.adoc[operator&equals;&equals;](
    std::nullopt&lowbar;t a,
    xref:absl/optional_ref-0c.adoc[optional&lowbar;ref&lt;T&gt;] b);
----

[.small]#xref:absl/operator_eq-0ab.adoc[_» more&period;&period;&period;_]#

Compares the referenced values of two `optional&lowbar;ref`s&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    typename T,
    typename U&gt;
constexpr
bool
xref:absl/operator_eq-0fb.adoc[operator&equals;&equals;](
    xref:absl/optional_ref-0c.adoc[optional&lowbar;ref&lt;T&gt;] a,
    xref:absl/optional_ref-0c.adoc[optional&lowbar;ref&lt;U&gt;] b);
----

[.small]#xref:absl/operator_eq-0fb.adoc[_» more&period;&period;&period;_]#

Compares a value to the referenced value of an `optional&lowbar;ref`&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    typename T,
    typename U,
    typename = &sol;&ast; implementation-defined &ast;&sol;&gt;
constexpr
bool
xref:absl/operator_eq-057.adoc[operator&equals;&equals;](
    T const& a,
    xref:absl/optional_ref-0c.adoc[optional&lowbar;ref&lt;U&gt;] b);
----

[.small]#xref:absl/operator_eq-057.adoc[_» more&period;&period;&period;_]#

Compares the referenced value of an `optional&lowbar;ref` to a value&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    typename T,
    typename U,
    typename = &sol;&ast; implementation-defined &ast;&sol;&gt;
constexpr
bool
xref:absl/operator_eq-009.adoc[operator&equals;&equals;](
    xref:absl/optional_ref-0c.adoc[optional&lowbar;ref&lt;T&gt;] a,
    U const& b);
----

[.small]#xref:absl/operator_eq-009.adoc[_» more&period;&period;&period;_]#

Compares two statuses for equality&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:absl/operator_eq-0b3.adoc[operator&equals;&equals;](
    xref:absl/Status.adoc[Status] const& lhs,
    xref:absl/Status.adoc[Status] const& rhs);
----

[.small]#xref:absl/operator_eq-0b3.adoc[_» more&period;&period;&period;_]#

Checks the equality of two `absl&colon;&colon;StatusOr&lt;T&gt;` objects&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;typename T&gt;
requires internal&lowbar;statusor&colon;&colon;IsEqualityComparable&lt;T&gt;&colon;&colon;value
bool
xref:absl/operator_eq-036.adoc[operator&equals;&equals;](
    xref:absl/StatusOr.adoc[StatusOr&lt;T&gt;] const& lhs,
    xref:absl/StatusOr.adoc[StatusOr&lt;T&gt;] const& rhs);
----

[.small]#xref:absl/operator_eq-036.adoc[_» more&period;&period;&period;_]#

Compares two `FastTypeIdType` values for equality&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
constexpr
bool
xref:absl/operator_eq-08f.adoc[operator&equals;&equals;](
    xref:absl/FastTypeIdType.adoc[FastTypeIdType] a,
    xref:absl/FastTypeIdType.adoc[FastTypeIdType] b);
----

[.small]#xref:absl/operator_eq-08f.adoc[_» more&period;&period;&period;_]#

Compares two `UnrecognizedFlag` instances for equality&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:absl/operator_eq-0e4.adoc[operator&equals;&equals;](
    xref:absl/UnrecognizedFlag.adoc[UnrecognizedFlag] const& lhs,
    xref:absl/UnrecognizedFlag.adoc[UnrecognizedFlag] const& rhs);
----

[.small]#xref:absl/operator_eq-0e4.adoc[_» more&period;&period;&period;_]#

== Return Value

* `true` if the parameter sets are equal&period;
* `true` if the distributions have equal parameter sets&period;
* `true` if the spans have equal elements&period;
* `true` if `a` and `b` point to the same position&period;
* true if the iterators are equal&period;
* `true` if the maps are equal&period;
* `true` if the sets are equal&period;
* `true` if the arrays have equal size and equal elements&period;
* `true` if the operands have equal elements&period;
* `true` if `lhs` equals `rhs`&period;
* `true` if `a` and `b` refer to the same zone&period;
* `true` if `f` is empty&period;
* `true` if `lhs` equals `rhs`&semi; `false` otherwise&period;
* `true` if the vectors are equal, `false` otherwise&period;
* `true` if both values are equal&period;
* `true` if the contents are equal&period;
* `true` if the Cords hold equal contents&period;
* `true` if `a` is empty&period;
* `true` if `b` is empty&period;
* `true` if both are empty or both hold equal values&period;
* `true` if `b` holds a value equal to `a`&period;
* `true` if `a` holds a value equal to `b`&period;
* `true` if the two statuses are equal&period;
* `true` if both hold equal values or equal statuses&period;
* `true` if `a` and `b` identify the same type, `false` otherwise&period;
* `true` if `lhs` and `rhs` have the same source and flag name&period;

== Parameters

[cols="1,4"]
|===
| Name| Description
| *a*
| The first parameter set to compare&period;
| *b*
| The second parameter set to compare&period;
| *d1*
| The first distribution to compare&period;
| *d2*
| The second distribution to compare&period;
| *p1*
| The first parameter set to compare&period;
| *p2*
| The second parameter set to compare&period;
| *lhs*
| The left&hyphen;hand fixed array&period;
| *rhs*
| The right&hyphen;hand fixed array&period;
| *f*
| The `AnyInvocable` to check&period;
| *unused*
| Unused parameter&period;
| *x*
| The left&hyphen;hand string data&period;
| *y*
| The right&hyphen;hand Cord&period;
|===


[.small]#Created with https://www.mrdocs.com[MrDocs]#
