Question: I'm compiling the following program using Microsoft Visual C++, as a C++20 program:

```
#include <iostream>
#include <tuple>

int main()
{
    auto t1 = std::make_tuple("one", "two", "three");
    auto t2 = std::make_tuple("one", "two", "three");

    std::cout << "(t1 == t2) is " << std::boolalpha << (t1 == t2) << "\n";
    std::cout << "(t1 != t2) is " << std::boolalpha << (t1 != t2) << "\n";

    return 0;
}

```

When I run it, I see the following output:

```
(t1 == t2) is false
(t1 != t2) is true

```

The tuples are identical, so why does it have wrong comparison results? How do I fix this?

Answer: 
What is the type of `"one"`? This is not a string, but rather a string literal.

Your problem basically boils down to this code:

```
char const* a = "one";
char const* b = "one";

std::cout << "(a == b) is " << std::boolalpha << (a == b) << "\n";
std::cout << "(a != b) is " << std::boolalpha << (a != b) << "\n";

```

Which will most likely output the same result.

This is because a string literal will decay into a `char const*`. Comparing two pointer compares their location in memory. Now this is a matter of whether your compiler is folding string literals into one. If the string literals are folded, then they are gonna be equal, if they are not, they are not gonna be equal. This can vary with different optimization levels.

How can you fix your comparison then?

Preferably use `std::string_view` as you don't seem to need to own or change their content:

```
using namespace std::literals;

// ... 

auto t1 = std::make_tuple("one"sv, "two"sv, "three"sv);
auto t2 = std::make_tuple("one"sv, "two"sv, "three"sv);

```

The `std::string_view` class is a thin wrapper around a pointer and a size, and define a comparison operator that check for value equality.
`auto` is not always your friend. I would argue the proper way to get reliably the “right” behaviour without boilerplate is to explicitly use a type that you know has value-equality. Then you can also omit the `make_tuple` and simply use the initialiser-list constructor:

```
#include <string>
#include <tuple>
#include <iostream>

typedef std::tuple<std::string, std::string, std::string> StrTriple;

int main() {

  StrTriple t1{"one", "two", "three"};
  StrTriple t2{"one", "two", "three"};

  std::cout << "(t1 == t2) is " << std::boolalpha << (t1 == t2) << "\n";
  std::cout << "(t1 != t2) is " << std::boolalpha << (t1 != t2) << "\n";

    return 0;
}

```

No doubt some would argue that the memory management of `std::string` incurs unnecessary overhead. `string_view` *may* be preferrable, however chances are in a real-world application the strings will need to be dynamically allocated anyway somewhere.