I&#39;ve noticed someone using the PHP operator `===` which I can&#39;t make sense out of. I&#39;ve tried it with a function, and it corresponds in crazy ways.

What is the definition of this operator? I can&#39;t even find it in the declaration of PHP operators.


What does &quot;===&quot; mean?

According to [cppreference](https://en.cppreference.com/w/cpp/types/type_info/operator_cmp), `std::type_info::operator!=` gets removed with C++20, however, `std::type_info::operator==` apparently remains.

What&#39;s the reasoning behind? I might agree on comparing for inequality being meaningless, but then comparing for equality would be just as meaningless as well, wouldn&#39;t it?

Similarly, `operator!=` of many other standard library types, including containers such as [`std::unordered_map::operator!=`][2] and [`std::unordered_set::operator!=`][3] will be removed in C++20 according to cppreference.

Having to write `if(!(id1 == id2))` doesn&#39;t make any code any clearer compared to `if(id1 != id2)`, in contrast, just the opposite...

[2]: https://en.cppreference.com/w/cpp/container/unordered_map/operator_cmp
[3]: https://en.cppreference.com/w/cpp/container/unordered_set/operator_cmp

Why is operator!= removed in C++20 for many standard library types?

How to select a result of comparison operator as a field with type BIT?

How it does work in `C#`:

    bool isGreater = FieldA &gt; FieldB;

How it doesn&#39;t work in `T-SQL`:

    SELECT (FieldA &gt; FieldB) AS BIT FROM t

How to write such task properly?

Using comparison operators in SELECT clause of T-SQL query

According to [cppreference][1], the `operator!=` of many standard library types, including [`std::unordered_map::operator!=`][2] and [`std::unordered_set::operator!=`][3] is *removed* in C++20.

**What is the committee&#39;s rationale behind the decision?** Won&#39;t this make the comparison support asymmetric?


  [1]: http://en.cppreference.com/w/cpp
  [2]: https://en.cppreference.com/w/cpp/container/unordered_map/operator_cmp
  [3]: https://en.cppreference.com/w/cpp/container/unordered_set/operator_cmp

Removed operator!= in C++20 standard library

What is the Ruby `&lt;=&gt;` (spaceship) operator? Is the operator implemented by any other languages?

What is the Ruby &lt;=&gt; (spaceship) operator?

I&#39;m trying to compare two numbers in R as a part of a if-statement condition:

`(a-b) &gt;= 0.5`

In this particular instance, a = 0.58 and b = 0.08... and yet `(a-b) &gt;= 0.5` is false.  I&#39;m aware of the dangers of using `==` for exact number comparisons, and this seems related:

`(a - b) == 0.5)` is false, while 

`all.equal((a - b), 0.5)` is true.

The only solution I can think of is to have two conditions: `(a-b) &gt; 0.5 | all.equal((a-b), 0.5)`.  This works, but is that really the only solution?  Should I just swear off of the `=` family of comparison operators forever?


**Edit for clarity:** I know that this is a floating point problem.  More fundamentally, what I&#39;m asking is: what should I do about it?  What&#39;s a sensible way to deal with greater-than-or-equal-to comparisons in R, since the `&gt;=` can&#39;t really be trusted?

Numeric comparison difficulty in R

Why does the following statement return false in JavaScript?

    new String(&#39;hello&#39;) === new String(&#39;hello&#39;)

Why does new String(&#39;hello&#39;) === new String(&#39;hello&#39;) evaluate to False?

Why is === faster than == in PHP?

Yesterday I stumbled over this when I modified PHP code written by someone else. I was baffled that a simple comparison (`if ($var ==! &quot; &quot;)`) didn&#39;t work as expected. After some testing I realized that whoever wrote that code used `==!` instead of `!==` as comparison operator. I&#39;ve never seen `==!` in any language so I wondered how the hell this code could even work and did some testing:

    &lt;?php
    echo &quot;int\n&quot;;
    echo &quot;1 !== 0: &quot;; var_dump(1 !== 0);
    echo &quot;1 !== 1: &quot;; var_dump(1 !== 1);
    echo &quot;1 ==! 0: &quot;; var_dump(1 ==! 0);
    echo &quot;1 ==! 1: &quot;; var_dump(1 ==! 1);
    echo &quot;bool\n&quot;;
    echo &quot;true !== false: &quot;; var_dump(true !== false);
    echo &quot;true !== true: &quot;; var_dump(true !== true);
    echo &quot;true ==! false: &quot;; var_dump(true ==! false);
    echo &quot;true ==! true: &quot;; var_dump(true ==! true);
    echo &quot;string\n&quot;;
    echo &#39;&quot;a&quot; !== &quot; &quot;: &#39;; var_dump(&quot;a&quot; !== &quot; &quot;);
    echo &#39;&quot;a&quot; !== &quot;a&quot;: &#39;; var_dump(&quot;a&quot; !== &quot;a&quot;);
    echo &#39;&quot;a&quot; ==! &quot; &quot;: &#39;; var_dump(&quot;a&quot; ==! &quot; &quot;);
    echo &#39;&quot;a&quot; ==! &quot;a&quot;: &#39;; var_dump(&quot;a&quot; ==! &quot;a&quot;);
    ?&gt;

This produces this output:

&lt;!-- language: lang-none --&gt;

    int
    1 !== 0: bool(true)
    1 !== 1: bool(false)
    1 ==! 0: bool(true)
    1 ==! 1: bool(false)
    bool
    true !== false: bool(true)
    true !== true: bool(false)
    true ==! false: bool(true)
    true ==! true: bool(false)
    string
    &quot;a&quot; !== &quot; &quot;: bool(true)
    &quot;a&quot; !== &quot;a&quot;: bool(false)
    &quot;a&quot; ==! &quot; &quot;: bool(false)
    &quot;a&quot; ==! &quot;a&quot;: bool(false)

The operator seems to work for boolean and integer variables, but not for strings. I can&#39;t find `==!` in the PHP documentation or anything about it on any search engine (tried Google, Bing, DuckDuckGo, but I suspect they try to interpret it instead of searching for the literal string). Has anybody seen this before and can shed any light on this behavior?

Difference between &quot;!==&quot; and &quot;==!&quot;

I want to find substring of the string or check if there is no such substring using Twig. On the words, I need analogue of &#39;strstr&#39; or &#39;strpos&#39; in php.
I googled and searched this issue in stackoverflow but nothing found. Does someone know how to solve this problem?

Find substring in the string in TWIG

Does the C++ specification define:

 1. the existence of the &#39;less than&#39; operator for boolean parameters, and if so,
 2. the result of the 4 parameter permutations?

In other words, are the results from the following operations defined by the specification?

    false &lt; false
    false &lt; true
    true &lt; false
    true &lt; true

On my setup (Centos 7, gcc 4.8.2) , the code below spits out what I&#39;d expect (given C&#39;s history of representing false as 0 and true as 1):

    false &lt; false = false
    false &lt; true = true
    true &lt; false = false
    true &lt; true = false

Whilst I&#39;m pretty sure most (all?) compilers will give the same output, is this legislated by the C++ specification? Or is an obfuscating, but specification-compliant compiler allowed to decide that true is less than false?

    #include &lt;iostream&gt;

    const char * s(bool a)
    {
      return (a ? &quot;true&quot; : &quot;false&quot;);
    }

    void test(bool a, bool b)
    {
      std::cout &lt;&lt; s(a) &lt;&lt; &quot; &lt; &quot; &lt;&lt; s(b) &lt;&lt; &quot; = &quot; &lt;&lt; s(a &lt; b) &lt;&lt; std::endl;
    }

    int main(int argc, char* argv[])
    {
      test(false, false);
      test(false, true);
      test(true, false);
      test(true, true);
      return 0;
    }

Is the operation &quot;false &lt; true&quot; well defined?

Looking into Queue.py in Python 2.6, I found this construct that I found a bit strange:

    def full(self):
        &quot;&quot;&quot;Return True if the queue is full, False otherwise
        (not reliable!).&quot;&quot;&quot;
        self.mutex.acquire()
        n = 0 &lt; self.maxsize == self._qsize()
        self.mutex.release()
        return n

If `maxsize` is 0 the queue is never full.

My question is how does it work for this case? How `0 &lt; 0 == 0` is considered False?

    &gt;&gt;&gt; 0 &lt; 0 == 0
    False
    &gt;&gt;&gt; (0) &lt; (0 == 0)
    True
    &gt;&gt;&gt; (0 &lt; 0) == 0
    True
    &gt;&gt;&gt; 0 &lt; (0 == 0)
    True


Why does the expression 0 &lt; 0 == 0 return False in Python?

Comparing two instances of the following struct, I receive an error:

    struct MyStruct1 {
        MyStruct1(const MyStruct2 &amp;_my_struct_2, const int _an_int = -1) :
            my_struct_2(_my_struct_2),
            an_int(_an_int)
        {}
    
        std::string toString() const;
    
        MyStruct2 my_struct_2;
        int an_int;
    };

The error is:

&gt; error C2678: binary &#39;==&#39; : no operator
&gt; found which takes a left-hand operand
&gt; of type &#39;myproj::MyStruct1&#39; (or there
&gt; is no acceptable conversion)

Why?


No == operator found while comparing structs in C++

If I do this:

    &gt;&gt;&gt; False in [False, True]
    True

That returns `True`. Simply because `False` is in the list.

But if I do:

    &gt;&gt;&gt; not(True) in [False, True]
    False

That returns `False`. Whereas `not(True)` is equal to `False`:

    &gt;&gt;&gt; not(True)
    False

Why?


Why does &quot;not(True) in [False, True]&quot; return False?

Does Python have something like an empty string variable where you can do:

    if myString == string.empty:

Regardless, what&#39;s the most elegant way to check for empty string values? I find hard coding `&quot;&quot;` every time for checking an empty string not as good.

How to check if the string is empty?




What is the difference between `==` and `===` in JavaScript?  I have also seen `!=` and `!==` operators.  Are there more such operators?

Difference between == and === in JavaScript

I was wondering if there is any way to detect if a number is negative in PHP?

I have the following code:

```php
$profitloss = $result-&gt;date_sold_price - $result-&gt;date_bought_price;
```

I need to find out if `$profitloss` is negative and if it is, I need to echo out that it is.

Detecting negative numbers

While checking the references for another question, I noticed an odd clause in C++11, at [expr.rel] &#182;3:

&gt; Pointers to `void` (after pointer conversions) can be compared, with a result defined as follows: If both
pointers represent the same address or are both the null pointer value, the result is `true` if the operator is
`&lt;=` or `&gt;=` and `false` otherwise; otherwise the result is unspecified.

This seems to mean that, once two pointers have been casted to `void *`, their ordering relation is no longer guaranteed; for example, this:

    int foo[] = {1, 2, 3, 4, 5};
    void *a = &amp;foo[0];
    void *b = &amp;foo[1];
    std::cout&lt;&lt;(a &lt; b);

would seem to be unspecified.

Interestingly, this clause wasn&#39;t there in C++03 and disappeared in C++14, so if we take the example above and apply the C++14 wording to it, I&#39;d say that &#182;3.1

&gt; - If two pointers point to different elements of the same array, or to subobjects thereof, the pointer to the element with the higher subscript compares greater.

would apply, as `a` and `b` point to elements of the same array, even though they have been casted to `void *`. Notice that the wording of &#182;3.1 was there pretty much the same in C++11, but seemed to be overridden by the `void *` clause.

Am I right in my understanding? What was the point of that oddball clause added in C++11 and immediately removed? Or maybe it&#39;s still there, but moved to/implied by some other part of the standard?

Why does C++11 contain an odd clause about comparing void pointers?

I&#39;m used to writing loops like this:

    for (std::size_t index = 0; index &lt; foo.size(); index++)
    {
        // Do stuff with foo[index].
    }

But when I see iterator loops in others&#39;  code, they look like this:

    for (Foo::Iterator iterator = foo.begin(); iterator != foo.end(); iterator++)
    {
        // Do stuff with *Iterator.
    }

I find the `iterator != foo.end()` to be offputting.  It can also be dangerous if `iterator` is incremented by more than one.

It seems more &quot;correct&quot; to use `iterator &lt; foo.end()`, but I never see that in real code.  Why not?

Why is &quot;!=&quot; used with iterators instead of &quot;&lt;&quot;?

There&#39;s a new comparison operator `&lt;=&gt;` in C++20. However I think in most cases a simple subtraction works well:

    int my_strcmp(const char *a, const char *b) {
        while (*a == *b &amp;&amp; *a != 0 &amp;&amp; *b != 0) {
            a++, b++;
        }
        // Version 1
        return *a - *b;
        // Version 2
        return *a &lt;=&gt; *b;
        // Version 3
        return ((*a &gt; *b) - (*a &lt; *b));
    }

They have the same effect. I can&#39;t really understand the difference.

All Comparison Operators Solutions on Gang of Coders

Total of 20 Comparison Operators Solutions

What does "===" mean?

Why is operator!= removed in C++20 for many standard library types?

Using comparison operators in SELECT clause of T-SQL query

Removed operator!= in C++20 standard library

What is the Ruby <=> (spaceship) operator?

Numeric comparison difficulty in R

Why does new String('hello') === new String('hello') evaluate to False?

Why is === faster than == in PHP?

Difference between "!==" and "==!"

Find substring in the string in TWIG

Is the operation "false < true" well defined?

Why does the expression 0 < 0 == 0 return False in Python?

No == operator found while comparing structs in C++

Why does "not(True) in [False, True]" return False?

How to check if the string is empty?

Difference between == and === in JavaScript

Detecting negative numbers

Why does C++11 contain an odd clause about comparing void pointers?

Why is "!=" used with iterators instead of "<"?

How is the three-way comparison operator different from subtraction?