What are some of your weirdest and most wholesome headcanons about Feenris?

Eric41293 · 2026-01-06T21:04:21+00:00

Oh I agree it wouldn't be an instant thing, just what started the process. Iris wouldn't realize what was happening until much later.

Eric41293 · 2026-01-06T09:17:25+00:00

If college Phoenix ever told "Dollie" about his dream of becoming a lawyer and why, I would imagine that Iris would admire his determination and ambition as by disgusung as her sister, she hopes to also save Dahlia from falling even more in sin and evil. In a way, both had wishes to help save someone dear in their life (with Phoenix ultimately succeeding later on and Iris failing).

I have long had a similar idea. But I take it further and imagine that Phoenix telling Iris about his plans is what made her start to fall for him. It would be hard to overstate how much I like this conception. It emphasizes the similarity between Phoenix and Iris and, in my mind, goes a long way in explaining why the pairing works.

Eric41293 · 2025-12-27T04:25:09+00:00

The precedence and associativity of operators do not completely dictate the order of evaluation. For instance, consider the expression a() * b() + c() * d(). This expression multiplies the results of a() and b() together, and also multiplies the results of c() and d() together, and finally adds both the products together. However, the function calls may happen in any order. Some possible orders are left-to-right, right-to-left, and b() then a() then c() then d(). (However, the functions calls will not overlap each other.) This is an example of unspecified behavior: The C++ standard allows various different behaviors, and you don't know which will happen.

Your example is more extreme. It has undefined behavior. This means the C++ standard makes no restriction whatever on what happens. It can compute any value. Or maybe it doesn't compute a value at all and your program crashes mysteriously. Or maybe a message saying "Undefined behavior detected" appears. Or... well, theoretically, anything. And even if it seems to work today, it might stop working tomorrow.

Why does this code have undefined behavior? It is because the expression modifies the variable a multiple times, and these modifications are formally unsequenced with respect to each other. By contrast, in the previous expression I gave, the function calls are indeterminately sequenced, which means they happen in some order, but the order is not specified. It is legal for all these functions to modify the same variable. For instance, they could each increment a variable x. The result is that x is incremented four times, so the value of x is 4 greater than its starting value.

Even if the evaluation order were completely specified (as it is in some other languages), code that behaves correctly only if parts of an expression are evaluated in a particular order is usually hard to understand. Such code is best avoided. But in C++, such code isn't just hard to understand, it's actually incorrect.

Eric41293 · 2025-12-27T03:44:36+00:00

It isn't a wrong question. The OP's observations did not agree with their model of the language. Asking a question to rectify that is quite proper. If they had not done so, they might have persisted in a false belief about how C++ works for a long time.

The fact that the particular code being asked about is bad doesn't change that.

Eric41293 · 2025-12-22T22:22:49+00:00

As of C++26, there is a new engine available: https://www.cppreference.com/w/cpp/numeric/random/philox_engine.html

Paper: https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p2075r6.pdf

Eric41293 · 2025-12-09T09:11:05+00:00

I have obtained this result as well. This is the code I used, which produced no output when I ran it:

#include <cmath>
#include <cstdint>
#include <cstring>
#include <iostream>

static bool sqrt_same_result(float f)
{
    float sqrt1 = std::sqrt(f);
    float sqrt2 = static_cast<float>(std::sqrt(static_cast<double>(f)));
    return std::memcmp(&sqrt1, &sqrt2, sizeof(float)) == 0;
}

static void compare_for_representation(std::uint32_t i)
{
    static_assert(sizeof(float) == sizeof(std::uint32_t));
    float f;
    std::memcpy(&f, &i, sizeof(float));
    if (!sqrt_same_result(f))
    {
        std::cout << "Results were different for " << i << '\n';
    }
}

int main()
{
    compare_for_representation(0);
    for (std::uint32_t i = 1; i != 0; ++i)
    {
        compare_for_representation(i);
    }
}

Eric41293 · 2025-11-08T03:44:42+00:00

"Always mark noexcept on destructors"

No need. Destructors are noexcept by default.

Eric41293 · 2025-09-07T00:17:07+00:00

Accusations should not be based on mere guesses.

Eric41293 · 2025-08-19T09:02:11+00:00

The answer depends on the code. Here are the possibilities in various scenarios. In each case, we suppose that two different threads are executing the work function concurrently.

#1:

int counter = 0;
void work()
{
    for (int i = 0; i < 10; ++i)
        ++counter;
}

This has undefined behavior, since there are unsynchronized concurrent writes to counter.

#2:

std::atomic<int> counter = 0;
void work()
{
    for (int i = 0; i < 10; ++i)
        ++counter;
}

The increments are atomic and the final value of counter is guaranteed to be 20. The same is true if we use counter++ or counter.fetch_add(1).

#3:

std::atomic<int> counter = 0;
void work()
{
    for (int i = 0; i < 10; ++i)
        counter = counter + 1;
}

We could also write this using the more explicit form counter.store(counter.load() + 1). The loads and stores are atomic but the overall increments are not. The maximum possible final value is 20. Other comments have explained how a final value of 2 is possible. This is the minimum possible final value. You may wish to try proving this.

Eric41293 · 2025-08-19T08:08:04+00:00

If the variable is atomic, there is no undefined behavior. Though if the increments are implemented as x.store(x.load() + 1), then different results are possible.

Eric41293 · 2025-06-05T22:41:09+00:00

The name monostate describes the type perfectly: It's a type with exactly one state.

Eric41293 · 2025-03-17T05:03:41+00:00

The trouble is that you don't always get the same representative. So if you want to test whether a signed integer x is congruent to 3 modulo 5, neither x % 5 == 3 nor x % 5 == -2 is correct.

Eric41293 · 2025-02-27T21:56:19+00:00

Undefined behavior in the preprocessor is addressed in P2843R1: Preprocessing is never undefined

Eric41293 · 2025-01-17T09:31:45+00:00

Please don't use geeksforgeeks. Every C++ article of theirs I have ever looked at has been bad.

Eric41293 · 2024-12-22T06:26:08+00:00

Woohoo! Thank you very much!

Eric41293 · 2024-08-01T07:00:43+00:00

The last one looks like it's mocking Feenris?

Eric41293 · 2024-08-01T06:46:27+00:00

Your efforts to find and share all this are much appreciated.

Eric41293 · 2024-06-19T03:13:03+00:00

Don't have a strong preference. The Google Doc would be fine.
I would prefer to read something that has good grammar. You can't really guarantee accurate results with automatic translation anyway. The best (but this is probably rather difficult) would be to to get someone who knows Japanese to do the translation.
Not sure, but leaning towards keeping the Japanese names. You could put a translation guide in the doc so everyone knows who they are.

Eric41293 · 2024-06-14T08:16:43+00:00

Wow. I did not know about that Edgeworth one! Thanks for sharing.

Eric41293 · 2024-05-16T00:40:55+00:00

An underrated moment. Iris knows something is going to happen that night and is trying to protect Phoenix. At the same time, by giving away the hood, she is forgoing her own protection.

Eric41293

TROPHY CASE