C++ Arduino字符*数组[]：“；“消失”；人物

我正在使用char*array[]存储串行打印数据

然而，数据正在从阵列中“消失”

当我多次打印同一个var时，问题似乎就出现了

串行输出：

Hello world !
Lorem ipsum dolor sit amet, consectetur adipiscing elit.
0 - Archivage de : Lorem ipsum dolor sit amet, consectetur adipiscing elit.
Affichage de l'historique : 
0Lorem ipsum dolor sit amet, consectetur adipiscing elit.
Lorem ipsum dolor sit amet, consectetur adipiscing elit.
1 - Archivage de : Lorem ipsum dolor sit amet, consectetur adipiscing elit.
Affichage de l'historique : 
0Lorem ip
1Lorem ipsum dolor sit amet, consectetur adipiscing elit.
Lorem ipsum dolor sit amet, consectetur adipiscing elit.
2 - Archivage de : Lorem ipsum dolor sit amet, consectetur adipiscing elit.
Affichage de l'historique : 
0Lorem ip
1Lore
2Lorem ipsum dolor sit amet, consectetur adipiscing elit.
Affichage de l'historique : 
0Lorem ip
1Lore
2Lorem ipsum dolor sit amet, consectetur adipiscing elit.

#include <SPI.h>
#include <Ethernet.h>

#include <shutterSerial.h>

ShutterSerial s = ShutterSerial();

void setup() {

  s.begin(115200);
  s.setVerboseLevel(DEBUG);
  String test("Lorem ipsum dolor sit amet, consectetur adipiscing elit.");
  s.print("Hello world !", INFO, true);
  s.print(test, INFO, true);
  s.print(test, INFO, true);
  s.print(test, INFO, true);


  s.historique_print();

}


void loop() {
}

Arduino草图：

Hello world !
Lorem ipsum dolor sit amet, consectetur adipiscing elit.
0 - Archivage de : Lorem ipsum dolor sit amet, consectetur adipiscing elit.
Affichage de l'historique : 
0Lorem ipsum dolor sit amet, consectetur adipiscing elit.
Lorem ipsum dolor sit amet, consectetur adipiscing elit.
1 - Archivage de : Lorem ipsum dolor sit amet, consectetur adipiscing elit.
Affichage de l'historique : 
0Lorem ip
1Lorem ipsum dolor sit amet, consectetur adipiscing elit.
Lorem ipsum dolor sit amet, consectetur adipiscing elit.
2 - Archivage de : Lorem ipsum dolor sit amet, consectetur adipiscing elit.
Affichage de l'historique : 
0Lorem ip
1Lore
2Lorem ipsum dolor sit amet, consectetur adipiscing elit.
Affichage de l'historique : 
0Lorem ip
1Lore
2Lorem ipsum dolor sit amet, consectetur adipiscing elit.

#include <SPI.h>
#include <Ethernet.h>

#include <shutterSerial.h>

ShutterSerial s = ShutterSerial();

void setup() {

  s.begin(115200);
  s.setVerboseLevel(DEBUG);
  String test("Lorem ipsum dolor sit amet, consectetur adipiscing elit.");
  s.print("Hello world !", INFO, true);
  s.print(test, INFO, true);
  s.print(test, INFO, true);
  s.print(test, INFO, true);


  s.historique_print();

}


void loop() {
}

#包括
#包括
#包括
ShutterSerial s=ShutterSerial（）；
无效设置（）{
s、 开始（115200）；
s、 设置详细级别（调试）；
字符串测试（“Lorem ipsum dolor sit amet，Concertetur Adipsicing Elite”）；
s、 打印（“你好，世界！”，信息，真实）；
s、 打印（测试、信息、真实）；
s、 打印（测试、信息、真实）；
s、 打印（测试、信息、真实）；
s、 历史的印刷品；
}
void循环（）{
}

shutterSerial.h

#ifndef shutterSerial
#define shutterSerial

#include <SPI.h>

#define HISTORYSIZE 20

enum Level {
  ERROR,
  INFO,
  STACK,
  DEBUG,
  };

class ShutterSerial {

  public:

    /*Constructeur*/
    ShutterSerial();
    static void begin(unsigned int baudRate);

    static void setVerboseLevel(unsigned int level);
    static unsigned int getVerboseLevel();

    static void print(String msg, int level, bool crlf);
    static void print(int msg, int level, bool crlf);
    static void print(char* msg, int level, bool crlf);

    static void historique_reset();
    /*Historique des messages séries. On ne conserve que les messages d'INFO et d'ERROR*/
    static char* _historique[HISTORYSIZE];
    static void historique_put(char* nouveau);
    static void historique_print();
    static unsigned int _compteur;

    static char* intToCharArray(int value, bool crlf);

  private:
    static Level _verbosite;

};
#endif

#ifndef shutterSerial
#定义shutterSerial
#包括
#定义历史大小20
枚举级别{
错误，
信息，
堆栈
调试，
};
类序列号{
公众：
/*建设者*/
ShutterSerial（）；
静态无效开始（无符号整数波特率）；
静态void setVerboseLevel（无符号整数级别）；
静态无符号int getVerboseLevel（）；
静态无效打印（字符串消息、整数级别、布尔crlf）；
静态无效打印（int msg、int level、bool crlf）；
静态无效打印（字符*消息，整数级，布尔crlf）；
静态无效历史重置（）；
/*信息和错误的历史记录*/
静态字符*_historyque[历史大小]；
静态无效历史（char*nouveau）；
静态无效历史打印（）；
静态无符号整数编译器；
静态字符*intToCharray（int值，bool crlf）；
私人：
静态级别_详细；
};
#恩迪夫

shutterSerial.cpp

#include "shutterSerial.h"

ShutterSerial::ShutterSerial() {}

/*Initialisation du niveau de verbosité à INFO*/
Level ShutterSerial::_verbosite = INFO;

char* ShutterSerial::_historique[HISTORYSIZE];
unsigned int ShutterSerial::_compteur = 0;
static char temp[128];


void ShutterSerial::begin(unsigned int baudRate) {
  Serial.begin(baudRate);
  /*Ces deux lignes permettent d'éviter de perdre le premier caractère affiché
  L'arduino à tendance à ne pas afficher le premier caractère.
  */
  while(!Serial);
  Serial.println("");
}

unsigned int ShutterSerial::getVerboseLevel() {
  return (unsigned int)_verbosite;
}

void ShutterSerial::setVerboseLevel(unsigned int level) {
  _verbosite = (Level) level;
}

void ShutterSerial::print(String msg, int level, bool crlf) {
  if(level <= _verbosite) {
    if (crlf) {
      Serial.println(msg);
      if(level <= INFO) {
        msg += "\n";
        msg.toCharArray(temp, msg.length());
        historique_put(temp);
      }
    }
    else {
      Serial.print(msg);
      if(level <= INFO) {
        msg.toCharArray(temp, msg.length());
        historique_put(temp);
      }
    }
  }
}
void ShutterSerial::print(int msg, int level, bool crlf) {
  if(level <= _verbosite) {
    if (crlf) {
      Serial.println(msg);
      if(level <= INFO) {
        // historique_put(ShutterSerial::intToCharArray(msg, true));
      }
    }
    else {
      Serial.print(msg);
      if(level <= INFO) {
        // historique_put(ShutterSerial::intToCharArray(msg, false));
      }
    }
  }
}
void ShutterSerial::print(char* msg, int level, bool crlf) {
  if(level <= _verbosite) {
    if (crlf) {
      Serial.println(msg);
      if(level <= INFO) {
        // strcat(msg, "\n");
        // historique_put(msg);
      }
    }
    else {
      Serial.print(msg);
      if(level <= INFO) {
        // historique_put(msg);
      }
    }
  }
}


/*Manipulation de l'historique*/

void ShutterSerial::historique_reset() {
  _compteur = 0;
}

void ShutterSerial::historique_put(char* nouveau) {
  Serial.print(_compteur);
  Serial.print(" - Archivage de : ");
  Serial.println(nouveau);
  _historique[_compteur] = (char*)malloc(sizeof(strlen(nouveau) + 1));
  memcpy(_historique[_compteur], nouveau, strlen(nouveau) + 1);
  _compteur = _compteur + 1;
  historique_print();

}

void ShutterSerial::historique_print() {
  int cpt = 0;
  Serial.println("Affichage de l'historique : ");

  if(_compteur > 0) {
    for(cpt = 0; cpt < _compteur; cpt++) {
      Serial.print(cpt);
      Serial.println(_historique[cpt]);
    }
  }
  else {
    Serial.println("L'historique est vide.");
  }
}

char* ShutterSerial::intToCharArray(int value, bool crlf) {
  char* convertedValue = (char*)malloc(sizeof(char));
  if(crlf) {
    sprintf(convertedValue, "%d\n", value);
  }
  else {
    sprintf(convertedValue, "%d", value);
  }
  return convertedValue;
}

#包括“shutterSerial.h”
ShutterSerial:：ShutterSerial（）{}
/*详细信息的初始化*/
级别：详细信息=信息；
char*ShutterSerial:：_historyque[HISTORYSIZE]；
无符号整数序列号：：_compteur=0；
静态字符温度[128]；
void ShutterSerial:：begin（无符号整数波特率）{
串行开始（波特率）；
/*这两件事都是在总理办公室里进行的
阿尔杜伊诺是总理卡拉特尔的助手。
*/
而（！串行）；
Serial.println（“”）；
}
unsigned int ShutterSerial:：getVerboseLevel（）{
返回（无符号整数）\详细信息；
}
void ShutterSerial:：setVerboseLevel（未签名的整数级别）{
_详细程度=（级别）级别；
}
void ShutterSerial:：print（字符串消息、int-level、bool-crlf）{
如果（level，让我们扩展这一行以提高可读性

_historique[_compteur] = (char*)malloc(sizeof(strlen(nouveau) + 1));

_historique[_compteur] = (char*)malloc(    sizeof( strlen(nouveau) + 1 )    );

这里您使用的是
sizeof（strlen（nouveau）+1）
，它等于
sizeof（int）

该行应为：

_historique[_compteur] = (char*)malloc( (strlen(nouveau) + 1) * sizeof(char)  );

我希望它是可读的！
让我们扩展这一行以提高可读性

_historique[_compteur] = (char*)malloc(sizeof(strlen(nouveau) + 1));

_historique[_compteur] = (char*)malloc(    sizeof( strlen(nouveau) + 1 )    );

这里您使用的是
sizeof（strlen（nouveau）+1）
，它等于
sizeof（int）

该行应为：

_historique[_compteur] = (char*)malloc( (strlen(nouveau) + 1) * sizeof(char)  );

我希望它是可读的！
为什么要使用malloc而不是new？或者更好，使_独一无二？为什么要使用malloc而不是new？或者更好，使_独一无二？