Mercury13

Почему нельзя? Пишу на Си с крестами, но там ничего специфичного нет, кроме парочки перестраховок.
В Си++20 появился ещё и bit_cast.

#include <iostream>

union DoubleInt {
    double asDouble;
    uint64_t asInt;
};

static_assert(sizeof(double) == sizeof(uint64_t), "Strange machine with double != int64");

constexpr int BITS_MANTISSA = 52;
constexpr int BITS_EXPONENT = 11;
constexpr int BITS_SIGN = 1;

static_assert(BITS_MANTISSA + BITS_EXPONENT + BITS_SIGN == 64, "Programmer's funkup");

constexpr uint64_t MANTISSA_UNIT = uint64_t(1) << BITS_MANTISSA;
constexpr uint64_t MANTISSA_MASK = MANTISSA_UNIT - 1;

constexpr int EXPONENT_SHIFT = BITS_MANTISSA;
constexpr uint64_t EXPONENT_MAX = (uint64_t(1) << BITS_EXPONENT) - 1;
constexpr uint64_t EXPONENT_ORIGIN = EXPONENT_MAX >> 1;
constexpr uint64_t EXPONENT_MASK = EXPONENT_MAX << EXPONENT_SHIFT;
constexpr uint64_t EXPONENT_SHIFTED_ORIGIN = EXPONENT_ORIGIN << EXPONENT_SHIFT;

constexpr int SIGN_SHIFT = BITS_MANTISSA + BITS_EXPONENT;
constexpr uint64_t SIGN_MASK = uint64_t(1) << SIGN_SHIFT;

int main()
{
    DoubleInt x { -3.45 };

    // Простите уж, без денормализованных чисел

    // Оставим знак и мантиссу
    DoubleInt xMantissa = x;
    xMantissa.asInt &= (MANTISSA_MASK | SIGN_MASK);
    // И добавим туда стандартный нулевой порядок
    xMantissa.asInt |= EXPONENT_SHIFTED_ORIGIN;

    // Извлечём порядок
    int exponent = ((x.asInt & EXPONENT_MASK) >> EXPONENT_SHIFT) - EXPONENT_ORIGIN;

    std::cout << xMantissa.asDouble << "*2^" << exponent << std::endl;

    return 0;
}

не удается преобразовать 'char*' в 'int*' для аргумента '1' в 'int

Как правило, ошибка. Функция хотела указатель на 4-байтовые слова — а мы передаём ей указатель на байты.
Если очень нужно рассматривать int* как char* (например, работаем не с данными какого-то определённого типа, а просто с байтами в памяти) — используйте reinterpret_cast.

недопустимое преобразование из 'int*' в 'int'

Почти всегда ошибка. Функция хотела число — а мы ей передаём ей указатель.
Если реально по какой-то причине нужно значение указателя воспринимать как число — используйте reinterpret_cast.

Возможен и другой вариант — вы просто упустили операцию «разыменовать» *.

warning: narrowing conversion of '143' from 'int' to 'char' inside

Точно ошибка — 143 не вписывается в char (−128…127). Если очень надо, используй static_cast.

Покажите лучше код, и я устрою ему ревизию.

const struct s & ref = f();
Этот механизм называется «продление жизни временного объекта».
Можно написать вот так.
struct s && ref = f();

Главная причина преобразования временного объекта только в const T& и T&& — тонкие ошибки при суперпозиции функций.
А именно — временный объект мы ни в коем случае не должны передать в функцию, принимающую s&.

void modify(s& arg) { ++arg[1]; }

...

modify(f());

Мы вызвали функцию f(), её результат передали в modify, и… похѣрили.

В любом языке можно только так.

namespace Addresses {
  uintptr_t myAddresses = processManager.xxx;
}

Только в CPP-файле; в хедере надо

namespace Addresses {
  extern uintptr_t myAddresses;
}

Но не советую по двум причинам.
1. Контроль задержек при инициализации программы — дело противное. На всех языках. Например, на Java ME я просил: все длинные операции делать, когда на экране что-то появится.
2. Вторая причина специфичная для Си++. Порядок инициализации разных модулей не определён. Если менеджер в одном модуле, а адреса в другом, адреса могут с вероятностью 50/50 инициализироваться, когда менеджера ещё нет.

Не сильно оптимизированный, но действующий код.
CONST_STR = string_view или const string& в зависимости от версии Си.
На выходе — кол-во замен.

size_t str::replace(
        std::string& aString,
        const char aWhat,
        const char aByWhat)
{
    size_t r = 0;
    FOR_S(i, 0, aString.length())
        if (aString[i] == aWhat) {
            aString[i] = aByWhat;
            ++r;
        }
    return r;
}

size_t str::replace(
        std::string &aString,
        char aWhat,
        CONST_STR aByWhat)
{
    if (aByWhat.length()==1)
    {   // Simple replace
        return str::replace(aString, aWhat, aByWhat[0]);
    }
    // More complex replace
    static const size_t szWhat = 1;
    const size_t szByWhat = aByWhat.length();
    size_t p = 0, r = 0;
    while ((p = aString.find(aWhat, p)) != std::string::npos)
    {
        aString.replace(p, szWhat, aByWhat);
        p += szByWhat;
        ++r;
    }
    return r;
}

1. Const-корректность придумал Бьярне Строуструп, и только ≈1999 её внесли в Си без крестов. А поскольку память, занятую строковым литералом, изменять запрещается (а в современных ОС литералы сидят в особом неизменяемом сегменте), понятное дело, новым типом для них стал const char*. Поскольку Си99 для совместимости позволял писать char* text = "foo";, а разработка Си(++) застопорилась на десятилетие, учебники по Си очень долго писали такую нерекомендуемую строчку.

3. Для маленьких объектов это одно и то же, но для больших немалая разница. Эта программа компилируется начиная с Си++17.

#include <iostream>

class WrapInt
{
public:
    int value = 0;
    WrapInt(int x) : value(x) {}
    WrapInt(WrapInt&) = delete;
private:
};

int main()
{
    WrapInt x = 42;
}

int zero = 0; до C++14 — создать временный объект, вызвать конструктор перемещения, а остальное делает оптимизатор. С Си++17 — вызов конструктора, если он не explicit. Мне казалось, что в очень старых версиях DJGPP был задействован op=, но ХЕЗ, MinGW и Си++03 вызывают именно конструктор.

int zero = int(0); — что удивительно, то же самое, только конструктор любой! Хотя выглядит как явное создание временного объекта.

int zero(0); — вызов конструктора во всех версиях Си++.

int zero{0}; — универсальный инициализатор Си++11, также вызов конструктора.

4. int array[] = { 1, 2, 3}; — все версии Си и Си++. int array[] { 1, 2, 3}; — универсальный инициализатор Си++11.

6. Эдсгер Дейкстра рассказал, почему массивы должны нумероваться с нуля, а целые диапазоны — задаваться в формате [a,b). Итак, у нас есть диапазон [a,b) и массив с запасом. Как сдвинуть b и добавить в диапазон один элемент? — array[b] = newElem; ++b;. Керниган и Ритчи решили объединить это чудо в одну строку array[b++] = newElem;, к тому же в процессорах действительно бывают пред- и постинкрементные операции.

7. void — это псевдотип, чьи элементы создавать нельзя. Указатели можно передвигать с шагом, который равен размеру типа — то есть прибавляем 1, реально прибавляется 1, 2, 4, 8 или сколько там. Для void*, который является простым указателем на память, шаг 1 байт. Или 1 слово, если машина оперирует более крупными словами — такие были, но из-за переусложнённой работы с текстом от них отказались. Но инкременты-декременты void*, если и возможны, то нежелательны, и вот почему.
Чтобы «соединить ежа с ужом» (длинное слово и доступ по байтам), x86 говорит: работа с невыровненными данными (например, 4 байта по адресу 21) будет происходить медленно и по неопределённому алгоритму. Itanium вообще, ЕМНИП, к невыровненным данным не обращается, как это устроено в компиляторах: char* → int* говорит, что обращаться нужно медленно и программно, void* → int* — быстро и аппаратно.

8. libc можно и не подключать, хоть это и сложно. А return из main НЕ вызывает std::exit. Линкер создаёт код обвязки, который открывает все глобальные объекты, вызывает main), закрывает все глобальные объекты и выходит из программы по-системному.

Это вообще как компилируете?
Если у вас MinGW и консольная программа, советую что-то вроде

-O3 -Os -static-libgcc -static-libstdc++ -static -lpthread

Получается самодостаточный EXE’шник, и для небольших программ ≈400K, для программ побольше — около 2М.