Мембер

По скорости использование m_var, this -> var эквивалентно?

Если оба мемберы, то да

А как думаешь откуда компилятор m_var будет брать?))

А вот черт его знает как оно работает. У нас имя this определено заранее, так вот что отличает переменную m_var в теле функции от переменной m_var экземпляра класса? Разве что соглашение использовать префикс (тогда использовать любые имена с префиксом как переменные тела функции некорректно и опасно)

в теле - ты имеешь в виду локальную переменную?

Да

тогда все очевидно. Если переменная локальная - то она на стеке. Обращение к ней стоит можно сказать ноль, компилятор даже вынесет такое в регистр если получиться

Для класса все сложнее, он может быть где угодно, и обращение к его полю требует от компилятора загрузить тот участок памяти, где он лежит и прочитать оттуда переменную

Если класс сам на стеке создан где-то рядом, то стоимость идентична с обращением к локальной переменной, иначе же может быть кеш-мисс, лишние инструкции загрузки

Это верно, но как компилятор их отличает друг от друга?

class A {
    public Foo(int value) {
        int m_var = value;  // На этом моменте компилятор поймет, что переменной нет в классе => она локальная, верно?
    }
}

class B: A {
    int m_var = 10; // Ошибки все еще не будет, но переменная может быть доступна в схожей же функции только через this
    public Bar(int value) {
        int m_var = value; // Другая переменная
        this -> m_var = 9; // Обращение к переменной класса
}

Я правильно понимаю?

Области видимости. Компилятор по умолчанию берет ту, что "глубже"

Чтобы объяснить ему, что тебе нужна другая, надо явно указать, откуда её брать

Можно честно писать ClassName::variable а-ля неймспейс

class A {
    public Foo(int value) {
        int m_var = value;  // На этом моменте компилятор поймет, что переменной нет в классе => она локальная, верно?
    }
}

class B: A {
    int m_var = 10; // Ошибки все еще не будет, но переменная может быть доступна в схожей же функции только через this
    public Bar(int value) {
        int m_var = value; // Другая переменная
        this -> m_var = 9; // Обращение к переменной класса
}

Код будет работать так, как я описал?

Не совсем. Ты получишь ошибку компиляции только если объявишь переменные с одинаковым именем в одной области видимости. Иначе одна будет перекрывать другую

Формально ты всегда можешь обращаться через this или наоборот опускать его, если переменную ничто не перекрывает

int m_var = ...
int this -> m_var = ...

Ошибка будет в этом случае?
1 - локальная в функции
2 - создаем переменную класса в функции

int this->m_var в целом невалидный код