#include<iostream>

 namespace std;    
  
class Test 
{ 
  static int i; 
  int j; 
}; 
  
int Test::i; 
  
int main() 
{ 
    cout << sizeof(Test); 
    return 0; 
} 
 

Что выведет программа?

#вопросы_с_собеседований
Что выведет код?

#include <iostream>

class A {
public:
    A() {}
    ~A() {
        throw 42;
    }
};

int main(int argc, const char * argv[]) {
    try {
        A a;
        throw 32;
    } catch(int a) {
        std::cout << a;
    }
}

Ответ: программа завершится аварийно.

⌨️ Основы C++

C++ — очень мощный язык программирования: на нём можно написать почти всё, что угодно. Его главная проблема для новичков заключается в том, что его невероятно сложно учить, по сравнению с остальными ЯП.

Если для вас это не проблема — вэлком в плейлист ниже:

1. Установка Visual studio — [4:03]
2. Первая программа — [12:09]
3. Первая программа. 2 часть — [10:29]
4. Структура и порядок выполнения программы.
5. #Include. using namespace — [15:17]

2D примитивы мультимедийной библиотеки SFML для разработки игр на C++.

https://habr.com/ru/post/702128/

#вопросы_с_собеседований
Что выведет код?

#include <iostream>

class A {
public:
    A() {}
    ~A() {
        throw 42;
    }
};

int main(int argc, const char * argv[]) {
    try {
        A a;
        throw 32;
    } catch(int a) {
        std::cout << a;
    }
}

Ответ: программа завершится аварийно.

#вопросы_с_собеседований

Как работает std::shared_ptr?

➖ std::shared_ptr — это умный указатель, который использует подсчет ссылок для управления жизненным циклом объекта. Это означает, что несколько shared_ptr могут указывать на один и тот же объект, и он будет удален только тогда, когда все shared_ptr, указывающие на него, будут уничтожены.

➖ Когда вы создаете shared_ptr, он увеличивает счетчик ссылок на объект. Когда shared_ptr уничтожается, он уменьшает счетчик ссылок. Если счетчик ссылок достигает нуля, это означает, что больше нет shared_ptr, указывающих на объект, и он может быть безопасно удален.

➖ std::shared_ptr также предоставляет набор методов для управления объектом, таких как reset, который позволяет заменить текущий объект новым, и use_count, который возвращает текущее количество shared_ptr, указывающих на объект.

Вот простой пример использования std::shared_ptr:

#include
#include
int main() {
std::shared_ptr ptr1(new int(5));
std::cout << *ptr1 << std::endl; // выводит 5
std::cout << ptr1.use_count() << std::endl; // выводит 1
{
std::shared_ptr ptr2 = ptr1;
std::cout << ptr1.use_count() << std::endl; // выводит 2
}
std::cout << ptr1.use_count() << std::endl; // выводит 1
}

Создаем std::shared_ptr, который владеет динамически выделенным объектом типа int. Затем еще один shared_ptr, который указывает на тот же объект. Когда второй shared_ptr выходит из области видимости и уничтожается, счетчик ссылок уменьшается, но объект не удаляется, потому что все еще есть другой shared_ptr, указывающий на него.

🚀🕛 Сортировка конфигов для Make сборок

Как известно любая большая программа на Си содержит много программных компонентов и, как следствие, много настроек: констант, макросов, конфигурационных структур и прочего. Всё это можно назвать одним словом: конфиги.

Все передают конфиги по-разному. Это один из религиозных аспектов в программировании микроконтроллеров.

1--Junior разработчики прописывают константы в каждом файле проекта или пихают всё в config.h, который потом вручную подключают #include(ом) во все *.с файлы,

2--Middle программисты передают конфиги через переменные окружения, которые определяют в скриптах сборки (Make, Cmake и т.п.).

3--Senior(ы) вообще передают конфиги через Device Tree и механизм Kconfig.

В статье не будут рассуждать как лучше и правильнее передавать конфиги в сборки. Разговор будет о том, как поступать, когда конфиги прописаны как переменные окружения в отдельном make файле по имени config.mk.

Читать статью

#почитать

#вопросы_с_собеседования

Что будет выведено на экран?

#include <iostream>

int a = 4;

int &f(int x){
  a = a + x;
  return a;
}

int main(void){
  int t = 5;
     std::cout << f(t) << std::endl; 
  f(t) = 20;
     std::cout << f(t) << std::endl; 
  t = f(t);
     std::cout << f(t) << std::endl;
}

В первом случае на печать выведется 9, потому что функция f принимает параметр t = 5, внутри функции к глобальной переменной a прибавляется 5, теперь a = 9, а f возвращает ссылку на неё и печатается значение a, то есть 9.

Далее неважно, что происходит внутри функции, важно, что возвращаемой ссылке на a присваивается 20, значит a = 20. Переменная t не поменяла своё значение, так как в функцию она передается по значению, а не по ссылке.

Затем опять вызываем f(5), при этом a = 20, a = 20 + 5, на печати увидим число 25.

Теперь присваиваем t значение a (в этот момент a = 25 + 5), значит, t станет равно 30.

И, наконец, последняя печать. Вызываем f(30), a = 30 + 30, и возвращается значение 60.