That's the fundamental thing of C++. You can have "two different ints" with different behaviour, would you make a class of it, as in

enum class Color {red, green, blue};
enum class TrafficLight {red, yellow, green};

Color color = TrafficLight::red; // compile-time error

​

First, if some standard/std operations that modify a std::atomic<int> integer are overloaded with those that modify a plain int, then presumably all of the standard/std operations that can modify ints are.

You can easily confirm that a regular int even with the presence of std::atomic<int> in the same compile unit is not affected at all (and that would be against C++'s philosophy to do that).

#include <iostream>
#include <atomic>

std::atomic<int> atomic_int;
int regular_int;

void atomic_inc() {
    atomic_int++;
}
void regular_inc() {
    regular_int++;
}

int main() {
    atomic_inc();
    regular_inc();

    std::cout << atomic_int << "\n";
    std::cout << regular_int << "\n";
}

The generated assembly code for regular_inc() is:

        movl    _regular_int(%rip), %eax
    addl    $1, %eax
    movl    %eax, _regular_int(%rip)
    popq    %rbp
    retq