Arduino.ru

ПС: я просто сторонник  упрощенного ООП, так как памяти маловато, но проекты все же сложнее сруба или землянки.Ну хочется все же в доме иметь толчок и ванную.Да так что бы не наблюдать в помещении новоднение говен. 

Все было кроме ООП...

Т.е. в структурах С++ нету "открытые закрытые и защищенные методы и наследование"?

Вот же ж блин! А я не знал, и всю жизнь использовал :-( 

Век живи - век учись. Пойду напьюсь :(

Квон, вас на лавры архата потянуло? ну вроде уже несколько раз было показано, что грамотное использование классов в ардуине не увеличивает кода, а опять эта шарманка про нехватку памяти...

Пух, в С++ структура и классики - одно и то же. Почти. 

А то при замене структуры на класс, флэша на 8 байт больше уходит.

​class TimerNode
  {
  public:
    uint32_t previous;
    uint32_t interval;
    Handler handler;
    TimerNode *pNext;

    TimerNode(uint32_t previous, uint32_t interval,
              Handler handler) : pNext(nullptr)
    {
      this->previous = previous;
      this->interval = interval;
      this->handler = handler;
    }
  };

Если это ответ на мой вопрос, то нещитова. Вопрос был "как заменяют структуру на класс". Вот и покажите мне одинаковые  структуру и класс, чтобы они память по-разному жрали. Например, если в приведённом примере слово class заменить на слово srtuct - по-другому жрать будет?

Что значит одинаковые? 

Я так думаю 8 Байт уходит на конструктор.

Одинаковые - значит одинаковые. Вы не знаете смысла этого слова? Посмотрите в словаре.

Не, ну нормально так. А в структуре конструктора, что, не было? Ну, тогда, давайте ещё 100500 методов припишем и скажем, что не на 8, а на 800 байтов отличается.

Нет, Вы одинаковые попробуйте. Например прямо в этом примере замените class на struct и сравните.

ЕвгенийП давайте лучше про Эру

STRUCT:

struct string
{
  char *i;
};

void setup()
{
  Serial.begin(9600);
  string *str = new string{"Hello, World!"};
  Serial.println(str->i);
  delete str;
}
void loop() {}

/*
  Скетч использует 1488 байт (4%) памяти устройства. Всего доступно 32256 байт.
  Глобальные переменные используют 202 байт (9%) динамической памяти, оставляя 1846 байт для локальных переменных. Максимум: 2048 байт.
*/

CLASS:

class string
{
  public:
    char *i;
  string(const char *i)
  {
    this->i = i;
  }
};

void setup()
{
  Serial.begin(9600);
  string *str = new string("Hello, World!");
  Serial.println(str->i);
  delete str;
}
void loop() {}

/*
  Скетч использует 1488 байт (4%) памяти устройства. Всего доступно 32256 байт.
  Глобальные переменные используют 202 байт (9%) динамической памяти, оставляя 1846 байт для локальных переменных. Максимум: 2048 байт.
*/

Пошел искать 8 байт :(

Всё ЕвгенийП, не судьба Вам сегодня напиться )))

struct string
{
  char *i;
};

void setup()
{
  Serial.begin(9600);
  string *str = new string{"Hello, World!"};
  Serial.println(str->i);
  delete str;
}
void loop() {}

/*
  Скетч использует 1488 байт (4%) памяти устройства. Всего доступно 32256 байт.
  Глобальные переменные используют 202 байт (9%) динамической памяти, оставляя 1846 байт для локальных переменных. Максимум: 2048 байт.
*/

class string
{
  public:
    char *i;
  string(const char *i)
  {
    this->i = i;
  }
};

void setup()
{
  Serial.begin(9600);
  string *str = new string("Hello, World!");
  Serial.println(str->i);
  delete str;
}
void loop() {}

/*
  Скетч использует 1488 байт (4%) памяти устройства. Всего доступно 32256 байт.
  Глобальные переменные используют 202 байт (9%) динамической памяти, оставляя 1846 байт для локальных переменных. Максимум: 2048 байт.
*/

Ну, пример-то не корректный - они ж разные! Я Вас просил сделать их одинаковыми. Вот так, например

class string
{
  public:
    char *i;
  string(const char *i)
  {
    this->i = i;
  }
};

и

struct string
{
  public:
    char *i;
  string(const char *i)
  {
    this->i = i;
  }
};

Вот теперь искать надо.

Ох... не знаю как Евгению а мне пришлось хряпнуть для храбрости, и приступить к изучению вопроса.

Взял в очередной раз в руки книжку и прочитал, что в С++ struct и class одно и то же.

Только модификаторы доступа по умолчанию разные struct - public, class - private.

А что использовать - это уже по вкусу.

Теперь все на своих полочках :) 

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

Вообще-то, на форуме это обсасывалось 100500 раз, и «поиск» находится в правом верхнем углу. Но, по случаю пятницы, специально для своего собрата по ленивости задницы, так и быть, приведу ещё один пример.

Вот перемигивалка для красно-синего проблескового маячка (как у полиции). Мигает то красным, то синим, со стандартной для маячков частотой 80 раз в минуту (4/3 Гц).

static constexpr uint16_t NormF = 80;	// стандартная частота (миганий/мин)
static constexpr uint16_t LightInterval = 30000 / NormF; // полупериод в мс

static constexpr uint8_t pinRed = 9, pinBlue = 8; // пины маячков

void setup() {
	pinMode(pinRed, OUTPUT);
	pinMode(pinBlue, OUTPUT);
	digitalWrite(pinBlue, HIGH);	// синий изначально горит
}

void loop() {
	digitalWrite(pinRed, digitalRead(pinBlue));	// Красный копируем с синего
	digitalWrite(pinBlue, ! digitalRead(pinBlue)); // А синий инвертируем
	delay(LightInterval);
}
//
//Скетч использует 1046 байт (3%) памяти устройства. Всего доступно 32256 байт.
//Глобальные переменные используют 9 байт (0%) динамической памяти, оставляя 2039 байт для локальных переменных. Максимум: 2048 байт.
//

А вот она же, но создан класс «Светодиод» и вся работа с двумя светодиодами (красным и синим) идёт через переменные этого класса

//
//	Определяем классик для работы с пинами
// 	Пух, сорян, лямбд не подвезли :(
//
#define AI	__attribute__((always_inline))
template <uint8_t P>
struct TheLED {
	void set(const uint8_t v) const AI { digitalWrite(P, v); }
	inline uint8_t get(void) const AI { return digitalRead(P); }
	inline void setMode(const uint8_t v) const AI { pinMode(P, v); }
};	

//
//	Интервал и пины такие же, ничего не поменялось
//
static constexpr uint16_t NormF = 80;	// стандартная частота (миганий/мин)
static constexpr uint16_t LightInterval = 30000 / NormF; // полупериод в мс

static constexpr uint8_t pinRed = 9, pinBlue = 8;	// пины маячков

//
//	Переменные для пинов через наш класс
//
TheLED <pinRed> red;
TheLED <pinBlue> blue;

//
//	Ну, а здесь пишем тоже самое, но не прямо,
//	а через переменные для пинов
//
void setup() {
	red.setMode(OUTPUT);
	blue.setMode(OUTPUT);
	blue.set(HIGH);	// синий изначально горит
}

void loop() {
	red.set(blue.get());	// Красный копируем с синего
	blue.set(! blue.get()); // А синий инвертируем
	delay(LightInterval);
}
//
//Скетч использует 1044 байт (3%) памяти устройства. Всего доступно 32256 байт.
//Глобальные переменные используют 9 байт (0%) динамической памяти, оставляя 2039 байт для локальных переменных. Максимум: 2048 байт.
//

Как видишь, с классом не то, что не больше, а даже меньше флеша. Почему меньше – это тебе на домашнее задание. Разбирайся.

Хоть бы подсказали с какой стороны разбираться. Не в шаблонах ли дело?

Тю! Да, шо такое? Тебе пример дай, да ещё разжуй его? Ты просил пример того, что использование классов не отжирает память? Ты его получил. Вот и любуйся на него. Пробуй поменять, посмотри, что получится. Шо ж всё что ли за тебя делать-то? так ты никогда ничего не поймёшь. Понимаешь. когда сам решаешь задачи, а не на дядю смотришь.

как можно что-то понять не видя реального машинного кода )))

еще и не зная ассемблер ))

А что он Вам даст? Там и так все понятно, смотреть надо внимательно. Как мне тут недавно тот же Ворота пенял (в другом, правда, контексте): "Рыба есть, ловить надо уметь" :)

повторюсь словами Деда - "Ваш лживый С++" )))

ЗЫ похоже врубился, в одном случае два раза получаем состояние пина, во втором, полученное ранее, просто инвертируем ?

Это из серии что прямой путь не самый быстрый. Лучше ездить по дорогам чем напрямки, но пехом.

ммм... а что на ардуинке с её то флешем в 32кб такие большие программы что надо городить ООП? ну сколько в среднестатистической программе для ардуинки кода? ну пусть 1000 строк, нафига там какое то ООП

Так может поступить только компилятор, который "клюшница делала". digitalRead - функция с побочным эффектом, её вызов игнорировать нельзя ни в каком случае: состояние пина-то могло и поменяться с прошлого вызова.

Да проще там всё, вы всё какие-то сложности ищете :)

Ну, знаете, кто-то любит попа, кто-то попадью, а кто-то и на попову дочку заглядывается.

Одним ООП надо "городить", а для других он как дыхание и "городить" надо, когда вдруг пришлось обходиться без него.

пока не гляну код машинный
мне "лживый" С ваш не понять )))

Переменные для пинов как константы штоли?
(всё, других вариантов нет)

А разве переменные для пинов не абсолютно одинаково описаны в обоих случаях?

 Что дает грамотное применение ООП- написать анатомически правильную программу. Ведь как природе,природа чуть-чуть подправила код и получился новый вид. И так постеменно появились более сложные формы жизни. И да литературы как написать анатомически правильную программу Вы не найдете. Максимум наметки или основные ошибки. Капитализм блин. Искусство написания анатомически правильной программы это ключевая технология в программировании, о которой прямо не положено говорить, потому что это коммерческая тайна.

Анатомически правильный или нет код это для обсуждения на форуме или за кружкой коньяка, важнее что бы он работал.

И не важно на 2 байта больше или на 8 меньше флеша скушает. Все больше и больше народу уже переходит на STM, ESP, туда где побольше памяти. Не хватило 32к возьмем 256к, на худой конец esp. А если ацки мега реальный проект то можно и малинку.

А ООП и призвано спрятать  анатомически не правильный говнокод от глаз обывателей в библиотеку.

Понимание правильного кода приходит только с каждой новой написанной строчкой, с каждыми новыми граблями и ни какие учебники в этом не помогут. 

У каждого найдется шо полечить ;)

Говнокод может то же вырости и дать потомство. Посмотрите только на обилие библиотек.

на мой взгляд анатомически правильная программа - это программа разбитая на отдельные модули-файлы а в крайнем случае поддиректории с набором файлов относящихся к одной подсистеме...

по сути это и есть ООП программа разбита на отдельные модули-подсистемы

посмотрите например на исходники операционной системы...

а лепить ключевое слово class и называть это ООП глупо, все можно написать на функциях без единого class и программа при этом будет модульной и объектно ориентированной

Вы сейчас говорите о модульности. Это не ООП.

Да и посмотрите на исходники ядра Linux.

А если почитать создателя C++ там как раз таки на каждом углу табличка лепи class где только сможешь, а если не смог пытайся.

И я уже промолчу про это:

public class Program{ 
      
    public static void main (String args[]){
          
        System.out.println("Hello, World!");
    }
}

В воздухе явственно повеяло ООП-срачем. Позвонил в доставку попкорна. Обещали в течение получаса. Жду.

_

Вся соль в этом синтаксическом сахаре )

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

как по мне ООП - оно уже есть. не хочешь - не пользуйся, ходи босиком по снегу.

пока что призывов не было чистая полемика

"Вот вам любовь-морковь, не хочете - не ешьте" :)))

Морковь полезная даже если не хочешь нужно кушать xD

Вернусь опять к правильности кода.Нужно определиться что есть рабочий код.Возьмем тот же пример с мигалкой.И в одном и в другом случае достигнут результат, работает. Так какой из этих двух вариантов правильней?

А вот с точки зрения размера, да один больше требует ресурсов, а второй меньше.

Так же само, если я выбрал "не верный алгоритм", который отберет больше ресурсов, но выполнит поставленную задачу, можно ли его называть неправильным. 

во, во, здоровее будешь )))

оба неправильные, там на ассемлере десяток строк, и флэша минимум съест )))

Если добавить еще и ассемблер в обсуждение, война миров начнется...