Поскольку “определение”, с математической точки зрения, ограничено документом в котором оно используется, то и определение понятия “переполнения” для разных языков программирования может быть различным. Далее рассмотрим, что такое переполнение в С/С++.

Начнём со второго вопроса, благо С/С++ предполагает возможность реализации IEC 60559 (IEEE 754), который писали видные математики.

С23 (ISO/IEC 9899:2023) в случае IEC 60559 (IEEE 754):

• Переполнение (FE_OVERFLOW/Overflow) это исключение, которое возникает при выполнении тех или иных операций, которое, по умолчанию, регистрируется во флагах статуса и/или, возможно, вызывает прерывание программы;
• Обычные операции (+/addition(x, y), fma()/fusedMultiplyAdd(x, y, z) или , sqrt()/squareRoot(x)…), а так же приведение целого типа к плавающему типу convertFromInt(int), должны выполнятся “абсолютно точно”, а результат округляться. При этом, как результат округления, может получиться ±∞;
• В случае, если при округлении получается ±∞, возникает исключение переполнения. Как следствие, для операций с точным результатом равным ±∞, например, 0 + +∞ -> +∞ такового исключения не возникает;
• Для операций преобразования к целому, таких как lround()/convertToIntegerTiesToAway(source) и др., при невозможности представления в указанном целом формате, возникает исключение некорректной операции (FE_INVALID/Invalid operation);
• Доступ к флагам статуса исключений с плавающей точкой (fetestexcept(), feclearexcept(), …) гарантируется, если прагма FENV_ACCESS “on”;
• Исключения с плавающей точкой должны учитываться в константных выражениях, если прагма FENV_ACCESS “on”;
• Указывается зависимыми от реализации (Unspecified behavior):
  • Состояние флагов статуса исключений с плавающей точкой при передаче управления между частями с прагмой FENV_ACCESS “on” и “off”;
  • Результат при преобразовании плавающего к целому, если возникло исключение некорректной операции (FE_INVALID/Invalid operation);

С23 (ISO/IEC 9899:2023) безотносительно к IEC 60559 (IEEE 754):

• Указывается зависимыми от реализации (Unspecified behavior):
  • Результат округления, если значение выходит за границы диапазона;
  • Результат функций lrint(), llrint(), lround() и llround(), если значение непредставимо соответствующим типом;

C++23 (ISO/IEC 14882:2023) холодно ссылается на актуальный ISO C.

Итого ответ на второй вопрос:

• Можно применять термин "переполнение" к действиям с плавающими числами, даже когда результатом может становится бесконечность (можно опросить флаги статуса исключений);
• Ваша изначальная формулировка про превышение максимального представимого значения в случае преобразования плавающего типа к целым типам неверна;
• Правда, в некоторых редких случаях, преобразования целых типов к плавающим типам, например unsigned long к float16_t/binary16, может возникать именно переполнение.

—

Относительно первого вопроса, к сожалению, ни C23, ни C++23 не содержат явного определения “переполнения” применительно к целым типам. Однако, “По плодам их узнаете их”.

Слово “overflow” встречается в С23 (ISO/IEC 9899:2023) всего на 42 страницах из 742, причём те из них, которые относятся к целым типам, описывают арифметические операции или вычисления выражений. Кроме, быть может, примечания к clock(void), но и там, скорее всего имеются ввиду переполнения при внутренних вычислениях.

С другой стороны, п. 6.3.1.3 описывает преобразование из знакового целого типа в беззнаковый без использования понятия “переполнения”. И обратное преобразование из беззнакового в знаковый, так же описывается без использования понятия “переполнения”, но как зависимое от реализации с возможным возникновением сигнала неопределённой природы.

Таким образом, с целым переполнениям дела обстоят примерно так же, как и с плавающим переполнением и, более менее, обоснованным ответом на первый вопрос в части C/C++ будет:

• беззнаковых переполнений не бывает, т.к. операции выполняются по модулю 2ⁿ;
• целые переполнения могут возникать при арифметических операциях и вычислении выражений целых знаковых типов;
• при преобразованиях между беззнаковыми и знаковыми целыми переполнений нет, но может возникать сигнал определяемый реализацией (соответственно, реализация его вправе назвать как угодно, в т.ч. и “overflow”, но это название уже за пределами языка С/С++).

—

В части реализаций можно отметить:

• clang поддерживает прагму FENV_ACCESS, поэтому в рамках C/C++ сравнительно легко доступны любые способы обработки любых исключений плавающей точки;
• gcc не поддерживает прагму FENV_ACCESS, поэтому всё непросто. Можно ли обрабатывать исключение в константных выражениях, лично мне, совсем неясно. Опрашивать флаги статуса надо с оглядкой на оптимизатор, по базе volatile и т.п. нет, но тот же NumPy справляется. Ну или, как вариант, для исключения FE_INVALID включать работу сигнала SIGFPE с помощью feenableexcept(), _controlfp_s() или какой-то матери в зависимости от платформы.

-- Для экспериментов:

#define _GNU_SOURCE 

#include <assert.h>
#include <fenv.h>
#include <math.h>
#include <stdlib.h>
#include <stdio.h>

#ifndef NOT_FENV_ACCESS
    #pragma STDC FENV_ACCESS ON
#endif

#ifndef USE_FEENABLEEXCEPT
    #define FEENABLEEXCEPT(excepts)
#else
    #define FEENABLEEXCEPT(excepts) feenableexcept(excepts)

    #if defined(__APPLE__) && defined(__MACH__)
        // Public domain polyfill for feenableexcept on OS X
        // http://www-personal.umich.edu/~williams/archive/computation/fe-handling-example.c

        #include <fenv.h>

        static
        inline int feenableexcept(unsigned int excepts)
        {
            static fenv_t fenv;
            unsigned int new_excepts = excepts & FE_ALL_EXCEPT;
            // previous masks
            unsigned int old_excepts;

            if (fegetenv(&fenv)) {
                return -1;
            }
            old_excepts = fenv.__control & FE_ALL_EXCEPT;

            // unmask
            fenv.__control &= ~new_excepts;
            fenv.__mxcsr   &= ~(new_excepts << 7);

            return fesetenv(&fenv) ? -1 : old_excepts;
        }
    #elif defined(_WIN32)
        // https://stackoverflow.com/a/30175525/8585880

        void feenableexcept(uint16_t fpflags){
            /*edit 2015-12-17, my attempt at ASM code was giving me
             *problems in more complicated scenarios, so I
             *switched to using _controlfp_s. I finally posted it here
             *because of the upvote to the ASM version.*/
            /*{// http://stackoverflow.com/questions/247053/
             uint16_t mask(FE_ALL_EXCEPT & ~fpflags);
             asm("fldcw %0" : : "m" (mask) : "cc");
            } //https://gcc.gnu.org/onlinedocs/gcc/Extended-Asm.html   */
            unsigned int new_word(0);
            if (fpflags & FE_INVALID) new_word |= _EM_INVALID;
            if (fpflags & FE_DIVBYZERO) new_word |= _EM_ZERODIVIDE;
            if (fpflags & FE_OVERFLOW) new_word |= _EM_OVERFLOW;
            unsigned int cw(0);
            _controlfp_s(&cw,~new_word,_MCW_EM);
        }
    #endif
#endif

void outtestexcept()
{
  int e = fetestexcept(-1);
  int unknown = ~(FE_DIVBYZERO|FE_INEXACT|FE_INVALID|FE_OVERFLOW|FE_UNDERFLOW);

  printf("%s%s%s%s%s%s\n",
          (e&FE_DIVBYZERO ? "FE_DIVBYZERO " : ""),
          (e&FE_INEXACT   ? "FE_INEXACT "   : ""),
          (e&FE_INVALID   ? "FE_INVALID "   : ""),
          (e&FE_OVERFLOW  ? "FE_OVERFLOW "  : ""),
          (e&FE_UNDERFLOW ? "FE_UNDERFLOW " : ""),
          (e&unknown      ? "unknown "      : "")
        );
}

int main()
{
    feclearexcept(-1);
    FEENABLEEXCEPT(~FE_INEXACT);

    feclearexcept(-1);
    const unsigned long cx = 1e20;

    outtestexcept();
    printf("cx: %lu\n", cx);

    feclearexcept(-1);
    unsigned long x = 1e20;

    outtestexcept();
    printf("x: %lu\n", x);

    double dr = rand() + 1e20;
    assert(dr >= 1e20);

    feclearexcept(-1);
    x = dr;
    outtestexcept();
    printf("%lg -> %lu\n", dr, x);

    feclearexcept(-1);
    x = lround(dr);
    outtestexcept();
    printf("%lg lround %lu\n", dr, x);

    for(int i = 0; i < 4; i++) {
        feclearexcept(-1);
        dr *= 1e100;
        outtestexcept();
        printf("%lg\n", dr);
    }

    return 0;
}