Arduino.ru

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

http://www.cyberforum.ru/cpp-builder/thread780240.html

А почитать доку/книгу? Выделили память для элемента через new - освободили через delete, а для массива еще и [] в обоих случаях. Для delete внутрь []  кол-во не указываем.

gonzales, элементы JRule, на которые ваш массив ссылается - не забываете чистить перед delete7

да, спасибо! 

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

Если не трудно, прокомментируйте, как изящнее решить следующую задачу.

На SD-карте хранится инфа об объекте в структурированных txt файлах. Я не знаю заранее, сколько объектов в определенный момент времени будет одновременно использоваться, есть только ограничение сверху (заведомо большое). Выделять память под все объекты - пустая трата ресурсов, потому как реально объектов может быть 3 или 5. При этом я должен иметь возможность обратиться к каждому из элементов. Я для удобстра использовал структуру и (видимо наивно) полагал, что динамический массив позволит мне выделять память под конкретный объект и затем ее освободить. Но походу delete затирает весь массив, а не отдельный элемент. Как быть в такой ситуации?

Не понятно написали, new, delete - сдесь все понятно, а что подразумевается под "а для массива еще и [] в обоих случаях. Для delete внутрь []  кол-во не указываем"???

Они вычищаются сразу после создания элемента

просто сделай, как по ссылке, что я дал - нет смысла перечислять бока, что ты напорол.

Да вы почти все сделали правильно, вам только массив обьектов нужно отделить от самих обьектов.

1. Описать структуру или класс для обьектов.

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

3. В массиве хранить только ссылку на обьект. Массив можно сделать статическим, ибо даже 10-20 ссылок - это совсем немного байт.

4. Когда нужда в обьекте отпадает - чистите сам обьект, удаляете ссылку на него из массива (заменяете на NULL) и удаляете обьект

принято это делать "ДО"

Я в общем-то думал, что именно так я и делаю. Структура есть, память выделяется динамически оператором new. Из того что я прочитал, я вынес, что диначеский массив - это и есть массив указателей. Если не затруднит, подскажите, как правильно описать объект и массив со ссылками

Что именно сделать? Удалить весь массив delete [] TRule, так мне это не надо. Я хочу удалить объект, чтобы он не съедал память и ссылку на него в массиве

Пока Вы не покажете код, разговор будет ни о чём.

Код в первом посте. Вопрос в основном теоретический, как сделать правильно.

struct TRule {
  byte SceneID; //<- размерность byte
  byte ElseSceneID;
};

Rule[RuleID] = new TRule;
Rule[RuleID]->SceneID = JRule["ExecuteScene"]; //<-- а присваиваеться хрен знает что
/*Rule[RuleID]->SceneID = 5;*/ //<-- а почему не так
Rule[RuleID]->ElseSceneID = JRule["ElseScene"];

Это не код, а огрызки. Хотите нормального разговора, давайте код, а если так - потрындеть ...

.del

В такой ситуации вместо массива используют список. В каждой структуре хранят указатель на другую/другие структуру. Например http://victor192007.narod.ru/files/cpp_d1.html

По ходу сам нашел.

Как писал b707 нужно удалить ссылку на объект в массиве. 

Rule[RuleNum]=NULL;
delete Rule[RuleNum];

По крайней мере у меня такая конструкция работает абсолютно корректно

Rule[RuleNum]=NULL;
delete Rule[RuleNum];

Простите, с чего Вы взяли, что она работает? Никакая память здесь не освобождается, объект остаётся в памяти. Ошибки нет, т.к. освобождение NULL - законная опреация, но она просто ничего не делает. Возьмите, наконец, MemoryExplorer и посмотрите, что творится у Вас с памятью.

Я вчера Вам писал, чтобы Вы дали нормальный код и реально собирался поработать и помочь Вам. Но кода Вы не даёте (не знаю почему), дело Ваше.

я запретил публиковать в общий доступ секретные российские разработки. О_О

Rule[RuleNum]=NULL;
delete Rule[RuleNum];

Нормальный код 20000 строк на 25 вкладках))))

Решил добить тему, заодно вдруг кому пригодится.

Вот тестовый код

struct TRule {
  byte SceneID;
  byte ElseSceneID;
};

TRule* Rule[50];

extern int __bss_end;
extern void *__brkval;
int i;

int memoryFree()
{
  int freeValue;
  if ((int)__brkval == 0)
    freeValue = ((int)&freeValue) - ((int)&__bss_end);
  else
    freeValue = ((int)&freeValue) - ((int)__brkval);
  return freeValue;
}

void setup() {
  Serial.begin(9600);
  Serial.print("Start. Free RAM = ");
  Serial.println(memoryFree());
  Serial.println("");
  i = 0;

}

void loop() {
  i++;
  Rule[3] = new TRule;
  Rule[3]->SceneID = 3;
  Rule[3]->ElseSceneID = 5;
  Serial.print("Create object. Free RAM ");
  Serial.print(i);
  Serial.print(" = ");
  Serial.println(memoryFree());
  Rule[3] = NULL;
  delete Rule[3];
  Serial.print("Delete object. Free RAM ");
  Serial.print(i);
  Serial.print(" = ");
  Serial.println(memoryFree());
  Serial.println("");
  delay(1000);


}

Как видно, действительно память не освобождается. (((

struct TRule {
  byte SceneID;
  byte ElseSceneID;
};

TRule* Rule[50];

extern int __bss_end;
extern void *__brkval;
int i;

int memoryFree()
{
  int freeValue;
  if ((int)__brkval == 0)
    freeValue = ((int)&freeValue) - ((int)&__bss_end);
  else
    freeValue = ((int)&freeValue) - ((int)__brkval);
  return freeValue;
}

void setup() {
  Serial.begin(9600);
  Serial.print("Start. Free RAM = ");
  Serial.println(memoryFree());
  Serial.println("");
  i = 0;

  TRule *r = new TRule;
  r->SceneID = 3;
  r->ElseSceneID = 5; 
  Serial.print("Create single object. Free RAM = ");
  Serial.println(memoryFree());
  delete r;
  Serial.print("Delete single object. Free RAM = ");
  Serial.println(memoryFree());
  Serial.println("");
  delay(1000);   

}

void loop() {
  /*i++;
  Rule[3] = new TRule;
  Rule[3]->SceneID = 3;
  Rule[3]->ElseSceneID = 5;
  Serial.print("Create object. Free RAM ");
  Serial.print(i);
  Serial.print(" = ");
  Serial.println(memoryFree());
  Rule[3] = NULL;
  delete [] Rule[3];
  Serial.print("Delete object. Free RAM ");
  Serial.print(i);
  Serial.print(" = ");
  Serial.println(memoryFree());
  Serial.println("");
  delay(1000);*/


}

Странно, но даже единичный объект не удаляется из памяти или memoryFree не правильно работает

а если строчки 

местами поменять? и скопки [] выкинуть?

Блин, ошибся, пока писал

Наоборот, сначала убиваем объект, потом вытираем ссылку.

Вот рабочий код

struct TRule {
  byte SceneID;
  byte ElseSceneID;
};

TRule* Rule[50];

extern int __bss_end;
extern void *__brkval;
int i;

int memoryFree()
{
  int freeValue;
  if ((int)__brkval == 0)
    freeValue = ((int)&freeValue) - ((int)&__bss_end);
  else
    freeValue = ((int)&freeValue) - ((int)__brkval);
  return freeValue;
}

void setup() {
  Serial.begin(9600);
  Serial.print("Start. Free RAM = ");
  Serial.println(memoryFree());
  Serial.println("");
  i = 0;

  TRule *r = new TRule;
  r->SceneID = 3;
  r->ElseSceneID = 5; 
  Serial.print("Create single object. Free RAM = ");
  Serial.println(memoryFree());
  
  delete r;
  r = NULL;
  Serial.print("Delete single object. Free RAM = ");
  Serial.println(memoryFree());
  Serial.println("");
  delay(1000);   

}

void loop() {
  i++;
  Rule[3] = new TRule;
  Rule[3]->SceneID = 3;
  Rule[3]->ElseSceneID = 5;
  Serial.print("Create object. Free RAM ");
  Serial.print(i);
  Serial.print(" = ");
  Serial.println(memoryFree());
  delete Rule[3];
  Rule[3] = NULL;
  Serial.print("Delete object. Free RAM ");
  Serial.print(i);
  Serial.print(" = ");
  Serial.println(memoryFree());
  Serial.println("");
  delay(1000);


}

Всем спасибо!!!

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

скобки после delete не нужны. Ты не массив удаляешь, а структурку.

Уже поправил, хотя так тоже отрабатывало, но скобки конечно не правильно

А зачем? Зачем вообще строка 54? На что она влияет? Открою Вам страшный секрет - она лишняя. Тоже о строке 36.

Вы неправильно походите к делу и потому работаете вслепую. То, что Вы где-то взяли memoryFree - это шаг в правильном направлении, но на самом деле Вам нужно сделать две вещи:

1. Использовать конструктор и деструктор Вашего объекта для печати информации о его создании / уничтожении. Вы удивитесь насколько легче станет жить, если открыть глаза и не работать вслепую.

2. Использовать не memoryFree, а полноценный монитор памяти.

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

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

А вот для того, чтобы не использовать занятие и освобождение памяти, добавлена возможность создавать массивы переменного размера - то, что Вам надо, с главным условием - в момент создания массива Вы должны знать его размер.

она не возвращается в алиэкспрес.

я так подозреваю, именно это Вы называли выше реальной помощью, такой "батя в здании" подошел и похлопал по плечу, "не ссы пацан, открой глаза и прыгай"!!!

По существу

1. Если строки 54 и 36 не нужны, возьмите код

struct TRule {
  byte SceneID;
  byte ElseSceneID;
};

TRule* Rule[50];

extern int __bss_end;
extern void *__brkval;
int i;

int memoryFree()
{
  int freeValue;
  if ((int)__brkval == 0)
    freeValue = ((int)&freeValue) - ((int)&__bss_end);
  else
    freeValue = ((int)&freeValue) - ((int)__brkval);
  return freeValue;
}

void setup() {
  Serial.begin(9600);
  Serial.print("Start. Free RAM = ");
  Serial.println(memoryFree());
  Serial.println("");
  i = 0;

  TRule *r = new TRule;
  r->SceneID = 3;
  r->ElseSceneID = 5; 
  Serial.print("Create single object. Free RAM = ");
  Serial.println(memoryFree());
  
  delete r;
  r = NULL;
  Serial.print("Delete single object. Free RAM = ");
  Serial.println(memoryFree());
  Serial.println("");
  delay(1000);   

}

void loop() {
  i++;
  if (Rule[3]!=NULL){
    Serial.println("FUCK, object still here");
  }
  Rule[3] = new TRule;
  Rule[3]->SceneID = 3;
  Rule[3]->ElseSceneID = 5;
  Serial.print("Create object. Free RAM ");
  Serial.print(i);
  Serial.print(" = ");
  Serial.println(memoryFree());
  delete Rule[3];
  //Rule[3] = NULL;
  Serial.print("Delete object. Free RAM ");
  Serial.print(i);
  Serial.print(" = ");
  Serial.println(memoryFree());
  Serial.println("");
  delay(1000);


}

и запустите. я с этого начал пост, что просто delete работает наполовину!!!

2. Накой мне полноценный монитор памяти? Чем конкретно плох memoryFree?

3. Страшная тайна, new и delete это и есть конструктор и деструктор, только тссс!!!

PS. Не люблю холивар, но уж как-то совсем все плохо. Особенно товарищ с "алиэкспрессом" порадовал, верх профессионализма

3. Страшная тайна, new и delete это и есть конструктор и деструктор, только тссс!!!

Никому такова не говори больше, это не совсем так. Вернее, совсем не так. 

Есть ли ссылка на какой-нить RTFM по этому поводу? 

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

RTFM -> труп Страуса. Прям вот самый штонинаесть первоисточник. 

ты не совсем точно понял смысл рекомендации - пропиши в структуру конструктор и деструктор, функциями которых будет печать("конструктор запущен"), печать("деструктор запущен").

чиста для удобства отладки - потом закомментишь.

а, придётся... О_О

Я может конечно безгранично туп, но вот вырезка из MSDN

class String {  
public:  
   String( char *ch );  // Declare constructor  
   ~String();           //  and destructor.  
private:  
   char    *_text;  
   size_t  sizeOfText;  
};  
  
// Define the constructor.  
String::String( char *ch ) {  
   sizeOfText = strlen( ch ) + 1;  
  
   // Dynamically allocate the correct amount of memory.  
   _text = new char[ sizeOfText ];  
  
   // If the allocation succeeds, copy the initialization string.  
   if( _text )  
      strcpy_s( _text, sizeOfText, ch );  
}  
  
// Define the destructor.  
String::~String() {  
   // Deallocate the memory that was previously reserved  
   //  for this string.  
   if (_text)  
      delete[] _text;  
}  
  
int main() {  
   String str("The piper in the glen...");  
}  

Как видим в конструкторе используется оператор new, а в деструкторе delete. (мопед не мой, я просто разместил объяву)

Но только это все для классов, мне зачем такие сложности, если тут просто структура? И какой смысл делать отдельный конструктор, если мне, чтобы убедиться, что объект создан достаточно того, что я вижу изменение используемой памяти, ну или на крайняк после создания объекта и присвоения значений вывести в монитор Serial.println(Rule[3]->SceneID);

при чём здесь утилизация переменных класса к отладке твоего кода?

да хоть Путин - как ты узнаешь, что делетнул его, если не видишь - упал или стоит?

Не понял о чём это. Какой мой пост Вы имеете в виду?

struct TRule {
  byte SceneID;
  byte ElseSceneID;
};

TRule* Rule[50];

extern int __bss_end;
extern void *__brkval;
int i;

int memoryFree()
{
  int freeValue;
  if ((int)__brkval == 0)
    freeValue = ((int)&freeValue) - ((int)&__bss_end);
  else
    freeValue = ((int)&freeValue) - ((int)__brkval);
  return freeValue;
}

void setup() {
  Serial.begin(9600);
  Serial.print("Start. Free RAM = ");
  Serial.println(memoryFree());
  Serial.println("");
  i = 0;

  TRule *r = new TRule;
  r->SceneID = 3;
  r->ElseSceneID = 5;
  Serial.print("Create single object. Free RAM = ");
  Serial.println(memoryFree());

  delete r;
  r = NULL;
  Serial.print("Delete single object. Free RAM = ");
  Serial.println(memoryFree());
  Serial.println("");
  delay(1000);

}

void loop() {
  i++;
  if (Rule[3] != NULL) {
    Serial.println("FUCK, object still here");
  }
  Rule[3] = new TRule;
  Rule[3]->SceneID = 3;
  Rule[3]->ElseSceneID = 5;
  Serial.print("Create object. Free RAM ");
  Serial.print(i);
  Serial.print(" = ");
  Serial.println(memoryFree());
  delete Rule[3];
  //Rule[3] = NULL;
  Serial.print("Delete object. Free RAM ");
  Serial.print(i);
  Serial.print(" = ");
  Serial.println(memoryFree());
  Serial.println("");
  delay(1000);
}

struct TRule {
	// КОНСТРУКТОР
	TRule(void) {
		Serial.print("Oject created: ");
		Serial.println((unsigned)this);
	}
	// ДЕСТРУКТОР
	~TRule(void) {
		Serial.print("Oject destroyed: ");
		Serial.println((unsigned)this);
	}
	byte SceneID;
	byte ElseSceneID;
};

TRule* Rule[50];

extern int __bss_end;
extern void *__brkval;
int i;

int memoryFree()
{
  int freeValue;
  if ((int)__brkval == 0)
    freeValue = ((int)&freeValue) - ((int)&__bss_end);
  else
    freeValue = ((int)&freeValue) - ((int)__brkval);
  return freeValue;
}

void setup() {
	Serial.begin(115200);
	Serial.print("Start. Free RAM = ");
	Serial.println(memoryFree());
	Serial.println("");
	i = 0;
	
	TRule *r = new TRule;
	r->SceneID = 3;
	r->ElseSceneID = 5; 
	Serial.print("Create single object. Free RAM = ");
	Serial.println(memoryFree());
	
	delete r;
	r = NULL;
	Serial.print("Delete single object. Free RAM = ");
	Serial.println(memoryFree());
	Serial.println("");
	delay(1000);   
}

void loop() {
	i++;
	if (Rule[3]!=NULL){
	 Serial.println("FUCK, object still here");
	}
	Rule[3] = new TRule;
	Rule[3]->SceneID = 3;
	Rule[3]->ElseSceneID = 5;
	Serial.print("Create object. Free RAM ");
	Serial.print(i);
	Serial.print(" = ");
	Serial.println(memoryFree());
	delete Rule[3];
	//Rule[3] = NULL;
	Serial.print("Delete object. Free RAM ");
	Serial.print(i);
	Serial.print(" = ");
	Serial.println(memoryFree());
	Serial.println("");
	delay(1000);
}

Start. Free RAM = 1528

Oject created: 766
Create single object. Free RAM = 1524
Oject destroyed: 766
Delete single object. Free RAM = 1528

Oject created: 766
Create object. Free RAM 1 = 1524
Oject destroyed: 766
Delete object. Free RAM 1 = 1528

FUCK, object still here
Oject created: 766
Create object. Free RAM 2 = 1524
Oject destroyed: 766
Delete object. Free RAM 2 = 1528

struct TRule {
	// КОНСТРУКТОР
	TRule(void) {
		Serial.print("Oject created: ");
		Serial.println((unsigned)this);
	}
	// ДЕСТРУКТОР
	~TRule(void) {
		Serial.print("Oject destroyed: ");
		Serial.println((unsigned)this);
	}
	byte SceneID;
	byte ElseSceneID;
};

TRule* Rule[50];

extern int __bss_end;
extern void *__brkval;
int i;

int memoryFree()
{
  int freeValue;
  if ((int)__brkval == 0)
    freeValue = ((int)&freeValue) - ((int)&__bss_end);
  else
    freeValue = ((int)&freeValue) - ((int)__brkval);
  return freeValue;
}

void setup() {
	Serial.begin(115200);
	Serial.print("Start. Free RAM = ");
	Serial.println(memoryFree());
	Serial.println("");
	i = 0;
	
	TRule *r = new TRule;
	r->SceneID = 3;
	r->ElseSceneID = 5; 
	Serial.print("Create single object. Free RAM = ");
	Serial.println(memoryFree());
	
	delete r;
	Serial.print("Delete single object. Free RAM = ");
	Serial.println(memoryFree());
	Serial.println("");
	delay(1000);   
}

void loop() {
	i++;
	Rule[3] = new TRule;
	Rule[3]->SceneID = 3;
	Rule[3]->ElseSceneID = 5;
	Serial.print("Create object. Free RAM ");
	Serial.print(i);
	Serial.print(" = ");
	Serial.println(memoryFree());
	delete Rule[3];
	Serial.print("Delete object. Free RAM ");
	Serial.print(i);
	Serial.print(" = ");
	Serial.println(memoryFree());
	Serial.println("");
	delay(1000);
}

Start. Free RAM = 1552

Oject created: 742
Create single object. Free RAM = 1548
Oject destroyed: 742
Delete single object. Free RAM = 1552

Oject created: 742
Create object. Free RAM 1 = 1548
Oject destroyed: 742
Delete object. Free RAM 1 = 1552

Oject created: 742
Create object. Free RAM 2 = 1548
Oject destroyed: 742
Delete object. Free RAM 2 = 1552

Oject created: 742
Create object. Free RAM 3 = 1548
Oject destroyed: 742
Delete object. Free RAM 3 = 1552

А ещё и там, и там используется оператор if и что с того? Делаем вывод, что if - это и есть конструктор (и деструктор заодно)? 

Структура (struct) - такой же точно класс как и class. Разница только в умолчательный аттрибутах методов и свойств.

Не знаю, туп ты или не туп, но то, что очень мало знаешь, и при этом хамоват - это точно.

Это хороше что порадовал "алиэкспрессом",  проффесиональный подход из #17 вам ведь оказался совершенно неинтересен. Значить бум развлекатся, писать говнокод, холиварить о конструкторе ))) Пятница ведь!