C++关系运算符 #

#include <iostream>

int main() {
    int a = 10, b = 20;
    
    std::cout << std::boolalpha;  // 输出true/false而非1/0
    
    std::cout << "a == b: " << (a == b) << std::endl;  // false
    std::cout << "a != b: " << (a != b) << std::endl;  // true
    std::cout << "a > b: " << (a > b) << std::endl;    // false
    std::cout << "a < b: " << (a < b) << std::endl;    // true
    std::cout << "a >= b: " << (a >= b) << std::endl;  // false
    std::cout << "a <= b: " << (a <= b) << std::endl;  // true
    
    return 0;
}

int a = 10;
int b = 10;
int c = 20;

bool r1 = (a == b);  // true
bool r2 = (a == c);  // false

int x = 5;

// 错误：使用赋值运算符=
if (x = 10) {  // x被赋值为10，条件为true
    // ...
}

// 正确：使用比较运算符==
if (x == 10) {
    // ...
}

// 防止错误的写法（Yoda条件）
if (10 == x) {  // 如果写成10 = x会编译错误
    // ...
}

// 不推荐：直接比较浮点数
double a = 0.1 + 0.2;
double b = 0.3;
bool equal = (a == b);  // 可能为false！

// 推荐：使用误差范围
#include <cmath>

bool isEqual(double x, double y, double epsilon = 1e-9) {
    return std::abs(x - y) < epsilon;
}

bool equal = isEqual(a, b);  // true

#include <string>

// C风格字符串（char*）
const char* s1 = "hello";
const char* s2 = "hello";
bool r1 = (s1 == s2);  // 比较指针地址，不是内容！

// 使用strcmp
#include <cstring>
bool r2 = (strcmp(s1, s2) == 0);  // 比较内容

// C++ string
std::string str1 = "hello";
std::string str2 = "hello";
bool r3 = (str1 == str2);  // 比较内容，true

int a = 10;
int b = 20;

bool notEqual = (a != b);  // true

// 检查值是否改变
int oldValue = 10;
int newValue = 20;

if (newValue != oldValue) {
    std::cout << "值已改变" << std::endl;
}

// 检查指针非空
int* ptr = nullptr;
if (ptr != nullptr) {
    std::cout << *ptr << std::endl;
}

int a = 10, b = 20;

bool greater = (a > b);   // false
bool less = (a < b);      // true
bool greaterEqual = (a >= b);  // false
bool lessEqual = (a <= b);     // true

int x = 5;

// 数学写法：1 < x < 10
// C++中不推荐这样写
bool result = (1 < x < 10);  // 实际是 (1 < x) < 10
// 1 < x 为 true（即1）
// 1 < 10 为 true
// 所以结果为 true

// 正确写法
bool result = (x > 1 && x < 10);  // true

char c1 = 'A';  // ASCII: 65
char c2 = 'a';  // ASCII: 97

bool r1 = (c1 < c2);   // true
bool r2 = (c1 > c2);   // false

// 比较字符大小
if (c1 >= 'A' && c1 <= 'Z') {
    std::cout << "大写字母" << std::endl;
}

// 关系运算符返回bool类型
bool result = (5 > 3);  // true

// 可以直接用于条件
if (5 > 3) {
    std::cout << "5大于3" << std::endl;
}

#include <iostream>

int main() {
    bool result = (5 > 3);
    
    // 默认输出1/0
    std::cout << result << std::endl;  // 1
    
    // 使用boolalpha输出true/false
    std::cout << std::boolalpha;
    std::cout << result << std::endl;  // true
    
    // 恢复默认
    std::cout << std::noboolalpha;
    std::cout << result << std::endl;  // 1
    
    return 0;
}

// 关系运算符优先级低于算术运算符
int a = 5, b = 3, c = 2;

bool r1 = a + b > c;      // 等价于 (a + b) > c，即 8 > 2，true
bool r2 = a > b + c;      // 等价于 a > (b + c)，即 5 > 5，false
bool r3 = a + b > b + c;  // 等价于 (a + b) > (b + c)，即 8 > 5，true

// < > <= >= 优先级高于 == !=
int a = 5, b = 3, c = 5;

bool r1 = a > b == c;     // 等价于 (a > b) == c，即 true == 5
                          // true转换为1，1 == 5为false

bool r2 = a == b < c;     // 等价于 a == (b < c)，即 5 == false
                          // false转换为0，5 == 0为false

// 不清晰
bool r = a > b == c;

// 清晰
bool r = (a > b) == c;

int i = 10;
double d = 10.0;

bool r1 = (i == d);  // true（整数提升为浮点数）

// 注意精度问题
int a = 1;
double b = 0.1;
bool r2 = (a == b * 10);  // 可能为false！

int s = -1;
unsigned int u = 1;

// 危险：有符号数会转换为无符号数
bool r = (s < u);  // false！-1转换为很大的无符号数

// 安全做法
bool r = (s < 0 || static_cast<unsigned int>(s) < u);

short s = 100;
int i = 100;
long l = 100L;

bool r1 = (s == i);  // true
bool r2 = (i == l);  // true

int score = 85;

if (score >= 90) {
    std::cout << "优秀" << std::endl;
} else if (score >= 80) {
    std::cout << "良好" << std::endl;
} else if (score >= 60) {
    std::cout << "及格" << std::endl;
} else {
    std::cout << "不及格" << std::endl;
}

// while循环
int i = 0;
while (i < 10) {
    std::cout << i << std::endl;
    i++;
}

// for循环
for (int i = 0; i < 10; i++) {
    std::cout << i << std::endl;
}

int age = 25;

// 检查是否在范围内
if (age >= 0 && age <= 120) {
    std::cout << "有效年龄" << std::endl;
}

// 检查是否在范围外
if (age < 0 || age > 120) {
    std::cout << "无效年龄" << std::endl;
}

int a = 10, b = 20, c = 15;

int maxVal = a;
if (b > maxVal) maxVal = b;
if (c > maxVal) maxVal = c;

int minVal = a;
if (b < minVal) minVal = b;
if (c < minVal) minVal = c;

// 使用std::max和std::min
#include <algorithm>
int maxVal = std::max({a, b, c});
int minVal = std::min({a, b, c});

#include <compare>

int a = 10, b = 20;

auto result = a <=> b;  // std::strong_ordering::less

if (result < 0) {
    std::cout << "a < b" << std::endl;
} else if (result > 0) {
    std::cout << "a > b" << std::endl;
} else {
    std::cout << "a == b" << std::endl;
}

// std::strong_ordering：强排序（完全可替代）
// std::weak_ordering：弱排序（等价但不相同）
// std::partial_ordering：部分排序（如浮点数有NaN）

double x = 3.14, y = 2.71;
auto result = x <=> y;  // std::partial_ordering

// 不推荐
if (a + b > c && d < e)

// 推荐
if ((a + b) > c && (d < e))

// 不推荐
if (x == 0.3)

// 推荐
if (std::abs(x - 0.3) < epsilon)

// 危险
for (int i = 0; i < vec.size(); i++)  // vec.size()返回size_t

// 安全
for (size_t i = 0; i < vec.size(); i++)
// 或
for (int i = 0; i < static_cast<int>(vec.size()); i++)

constexpr bool isInRange(int value, int min, int max) {
    return value >= min && value <= max;
}

static_assert(isInRange(5, 0, 10), "Value out of range");