[#operator_eq-073]
= operator==
:mrdocs:

Equality operators

== Synopses

Declared in `<arith_uint256.h>`

Compares two positions for equality of file index and offset.


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

[.small]#xref:operator_eq-0c6.adoc[_» more..._]#

Compare two destinations for equality by version and program.


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:operator_eq-04e.adoc[operator==](
    xref:WitnessUnknown.adoc[WitnessUnknown] const& w1,
    xref:WitnessUnknown.adoc[WitnessUnknown] const& w2);
----

[.small]#xref:operator_eq-04e.adoc[_» more..._]#

Compare two destinations for equality by their public keys.


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:operator_eq-045.adoc[operator==](
    xref:PubKeyDestination.adoc[PubKeyDestination] const& a,
    xref:PubKeyDestination.adoc[PubKeyDestination] const& b);
----

[.small]#xref:operator_eq-045.adoc[_» more..._]#

Compare two destinations for equality by their scripts.


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:operator_eq-06f.adoc[operator==](
    xref:CNoDestination.adoc[CNoDestination] const& a,
    xref:CNoDestination.adoc[CNoDestination] const& b);
----

[.small]#xref:operator_eq-06f.adoc[_» more..._]#

Test two fee rates for equality by their fee/vsize ratio.


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:operator_eq-0ad.adoc[operator==](
    xref:CFeeRate.adoc[CFeeRate] const& a,
    xref:CFeeRate.adoc[CFeeRate] const& b) noexcept;
----

[.small]#xref:operator_eq-0ad.adoc[_» more..._]#

Compare two extended keys for equality of all fields.


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:operator_eq-005.adoc[operator==](
    xref:CExtKey.adoc[CExtKey] const& a,
    xref:CExtKey.adoc[CExtKey] const& b);
----

[.small]#xref:operator_eq-005.adoc[_» more..._]#

Compare two private keys for equality of compression flag and key material.


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

[.small]#xref:operator_eq-0e7.adoc[_» more..._]#

Compare two KeyOriginInfo for equality.


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
constexpr
bool
xref:operator_eq-02.adoc[operator==](
    xref:KeyOriginInfo.adoc[KeyOriginInfo] const& a,
    xref:KeyOriginInfo.adoc[KeyOriginInfo] const& b) = default;
----

[.small]#xref:operator_eq-02.adoc[_» more..._]#

Compare two extended public keys for equality of all fields (excluding version).


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:operator_eq-012.adoc[operator==](
    xref:CExtPubKey.adoc[CExtPubKey] const& a,
    xref:CExtPubKey.adoc[CExtPubKey] const& b);
----

[.small]#xref:operator_eq-012.adoc[_» more..._]#

Compare two ellswift public keys for equality.


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:operator_eq-00b.adoc[operator==](
    xref:EllSwiftPubKey.adoc[EllSwiftPubKey] const& a,
    xref:EllSwiftPubKey.adoc[EllSwiftPubKey] const& b);
----

[.small]#xref:operator_eq-00b.adoc[_» more..._]#

Comparator implementation.


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:operator_eq-05d.adoc[operator==](
    xref:CPubKey.adoc[CPubKey] const& a,
    xref:CPubKey.adoc[CPubKey] const& b);
----

[.small]#xref:operator_eq-05d.adoc[_» more..._]#

Check whether two wrapped FeeFracs are equal (same fee and same size).


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:operator_eq-039.adoc[operator==](
    xref:ByRatioNegSize.adoc[ByRatioNegSize] const& a,
    xref:ByRatioNegSize.adoc[ByRatioNegSize] const& b) noexcept;
----

[.small]#xref:operator_eq-039.adoc[_» more..._]#

Compare two wrapped FeeFracs for equal feerate.


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:operator_eq-0cc.adoc[operator==](
    xref:ByRatio.adoc[ByRatio] const& a,
    xref:ByRatio.adoc[ByRatio] const& b) noexcept;
----

[.small]#xref:operator_eq-0cc.adoc[_» more..._]#

Check if two FeeFrac objects are equal (both same fee and same size).


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:operator_eq-03b.adoc[operator==](
    xref:FeeFrac.adoc[FeeFrac] const& a,
    xref:FeeFrac.adoc[FeeFrac] const& b) noexcept;
----

[.small]#xref:operator_eq-03b.adoc[_» more..._]#

Equality comparison between two deques (only compares size+contents, not capacity).


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

[.small]#xref:operator_eq-0a6.adoc[_» more..._]#

Compares two secure allocators for equality; they are always equal since the allocator is stateless.


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:operator_eq-06b.adoc[operator==](
    xref:secure_allocator.adoc[secure_allocator] const& a,
    xref:secure_allocator.adoc[secure_allocator<U>] const& b) noexcept;
----

[.small]#xref:operator_eq-06b.adoc[_» more..._]#

Compares two outpoints for equality.


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:operator_eq-076.adoc[operator==](
    xref:COutPoint.adoc[COutPoint] const& a,
    xref:COutPoint.adoc[COutPoint] const& b);
----

[.small]#xref:operator_eq-076.adoc[_» more..._]#

Tests whether two big integers are equal.


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:operator_eq-007d.adoc[operator==](
    xref:base_uint-02.adoc[base_uint<256>] const& a,
    xref:base_uint-02.adoc[base_uint<256>] const& b);
----

[.small]#xref:operator_eq-007d.adoc[_» more..._]#

Tests whether a big integer equals a 64‐bit value.


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:operator_eq-050.adoc[operator==](
    xref:base_uint-02.adoc[base_uint<256>] const& a,
    uint64_t b);
----

[.small]#xref:operator_eq-050.adoc[_» more..._]#

Tests whether two big integers are equal.


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:operator_eq-06d.adoc[operator==](
    xref:base_uint-02.adoc[base_uint] const& a,
    xref:base_uint-02.adoc[base_uint] const& b);
----

[.small]#xref:operator_eq-06d.adoc[_» more..._]#

Tests whether a big integer equals a 64‐bit value.


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:operator_eq-0ae.adoc[operator==](
    xref:base_uint-02.adoc[base_uint] const& a,
    uint64_t b);
----

[.small]#xref:operator_eq-0ae.adoc[_» more..._]#

Returns whether two addresses have equal time, service flags, and endpoint.


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

[.small]#xref:operator_eq-0c2.adoc[_» more..._]#

Compares two allocators for equality; they are always equal since the allocator is stateless.


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:operator_eq-038.adoc[operator==](
    xref:zero_after_free_allocator-01.adoc[zero_after_free_allocator<byte>] const& a,
    xref:zero_after_free_allocator-01.adoc[zero_after_free_allocator<U>] const& b) noexcept;
----

[.small]#xref:operator_eq-038.adoc[_» more..._]#

Compares two allocators for equality; they are always equal since the allocator is stateless.


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:operator_eq-01f.adoc[operator==](
    xref:zero_after_free_allocator-01.adoc[zero_after_free_allocator] const& a,
    xref:zero_after_free_allocator-01.adoc[zero_after_free_allocator<U>] const& b) noexcept;
----

[.small]#xref:operator_eq-01f.adoc[_» more..._]#

Compare two services for equality.


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:operator_eq-007e.adoc[operator==](
    xref:CService.adoc[CService] const& a,
    xref:CService.adoc[CService] const& b);
----

[.small]#xref:operator_eq-007e.adoc[_» more..._]#

Compare two addresses for equality.


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

[.small]#xref:operator_eq-0d.adoc[_» more..._]#

Compare two subnets for equality.


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:operator_eq-09.adoc[operator==](
    xref:CSubNet.adoc[CSubNet] const& a,
    xref:CSubNet.adoc[CSubNet] const& b);
----

[.small]#xref:operator_eq-09.adoc[_» more..._]#

Compares two pool allocators for equality.


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template<
    class T1,
    class T2,
    std::size_t MAX_BLOCK_SIZE_BYTES,
    std::size_t ALIGN_BYTES>
bool
xref:operator_eq-019.adoc[operator==](
    xref:PoolAllocator-0e.adoc[PoolAllocator<T1, MAX_BLOCK_SIZE_BYTES, ALIGN_BYTES>] const& a,
    xref:PoolAllocator-0e.adoc[PoolAllocator<T2, MAX_BLOCK_SIZE_BYTES, ALIGN_BYTES>] const& b) noexcept;
----

[.small]#xref:operator_eq-019.adoc[_» more..._]#

Compares two transactions for equality by witness hash.


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:operator_eq-05b.adoc[operator==](
    xref:CTransaction.adoc[CTransaction] const& a,
    xref:CTransaction.adoc[CTransaction] const& b);
----

[.small]#xref:operator_eq-05b.adoc[_» more..._]#

Compares two outputs for equality.


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

[.small]#xref:operator_eq-0ee.adoc[_» more..._]#

Compares two inputs for equality.


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:operator_eq-07a.adoc[operator==](
    xref:CTxIn.adoc[CTxIn] const& a,
    xref:CTxIn.adoc[CTxIn] const& b);
----

[.small]#xref:operator_eq-07a.adoc[_» more..._]#

== Return Value

* true if both the file index and offset are equal.
* True if both hold equal versions and programs.
* True if both hold equal public keys.
* True if both hold equal scripts.
* `true` if the fee rates are equal.
* true if all fields are equal.
* true if both keys have the same compression flag and byte data.
* true if both the fingerprint and path are equal.
* true if depth, fingerprint, child index, chain code and pubkey are equal.
* true if both keys have identical bytes.
* true if both public keys have identical serialized bytes.
* True if the underlying FeeFracs are equal.
* True if the two FeeFracs have the same feerate.
* True if both the fee and the size are equal.
* true if both deques have the same size and equal elements in order.
* Always true.
* True if both the hash and index are equal.
* True if `a` and `b` are equal, otherwise false.
* True if `a` equals `b,` otherwise false.
* true if both addresses have equal time, service flags, and endpoint.
* True when both services are equal.
* True when both addresses are equal.
* True when both subnets are equal.
* True when both allocators share the same backing resource.
* True if both transactions have the same witness hash.
* True if both the value and spending script are equal.
* True if the outpoint, signature script and sequence all match.

== Parameters

[cols="1,4"]
|===
| Name| Description
| *a*
| The first position.
| *b*
| The second position.
| *w1*
| The first destination.
| *w2*
| The second destination.
|===


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