Aborted (core dumped)

Version imprimable

Bonsoir,
j'apprends actuellement le C++ sur la chaine "Un prof très spécial" de Jacques-Olivier Lapeyre

J'ai fait exactement comme lui pour le code mais à la différence c'est que j'ai un corps dumped.

je vous donne le code du main, .h .cc

Le main :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
#include <iostream>
#include <string>
 
#include "intarray.h"
 
int main ()
{
  using namespace std;
  extintarray A=extintarray(15,15);
  for(int i=0;i<A.length();i++)
    {
      A.set(i,i*5);
      cout<<A.get(i)<<" ";
    }
  cout<<endl;
 
  return 0;
}

Le .h :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
#ifndef INTARRAY_H
#define INTARRAY_H
 
#include <iostream>
#include <string>
 
const int INTARRAY_DEFAULT_ALLOC = 1024;
const int INTHEAP_DEFAULT_ALLOC = 1024;
 
class intarray {
 protected :
  int len;
  int *data;
 public :
  intarray ();
  intarray (int len);
  intarray (const intarray &A);
  ~intarray ();
  int get (int index);
  void set (int index, int n);
  int length ();
  friend std::ostream & operator<< (std::ostream & o, intarray & A);
};
 
class extintarray : public intarray 
{
 private :
  int alloc;
 protected :
  void alloc_more (int newsize);
 public :
  extintarray (); 
  extintarray (int alloc); 
  extintarray (int len, int alloc);
  ~extintarray ();
  void set (int index, int n); 
};
 
#endif

le .cc :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
 
#include "intarray.h"
 
std::ostream & operator<< (std::ostream & o, intarray & A)
{
  for (int i = 0; i <= A.len - 2; i++)
    o << A.data[i] << ", ";
  o << A.data[A.len - 1];
  return o;
}
 
intarray::intarray (const intarray &A)
{
  this->len = A.len;
  this->data = new int [A.len];
  for (int i = 0; i < A.len; i++)
    this->data[i] = A.data[i];
}
 
int intarray::length ()
{
  return this->len;
}
 
intarray::intarray ()
{
  this->len = INTARRAY_DEFAULT_ALLOC;
  this->data = new int[INTARRAY_DEFAULT_ALLOC];
}
 
intarray::intarray (int len)
{
  this->len = len;
  this->data = new int[len];
}
 
intarray::~intarray ()
{
  delete[] this->data;
}
 
int intarray::get (int index)
{
  return this->data[index];
}
 
void intarray::set (int index, int n)
{
  this->data[index] = n;
}
 
extintarray::extintarray () : intarray ()
{
  this->alloc = INTARRAY_DEFAULT_ALLOC;
}
 
extintarray::extintarray (int alloc)
{
  this->len = 0;
  this->alloc = alloc;
  this->data = new int[alloc];
}
 
extintarray::extintarray (int len, int alloc)
{
  this->len = len;
  this->alloc = alloc;
  this->data = new int[alloc];
}
 
extintarray::~extintarray ()
{
  delete[] this->data;
}
 
void extintarray::set (int index, int n)
{
  if (index >= this->alloc)
    this->alloc_more (index * 2);
 
  if (index >= this->len)
    this->len = index + 1;
 
  this->data[index] = n;
}
 
void extintarray::alloc_more (int newsize)
{
  int* new_data = new int[newsize];
  for (int i = 0; i < this->len; i++)
    new_data[i] = this->data[i];
  delete[] this->data;
  this->data = new_data;
  this->alloc = newsize;
}

01/01/2017, 04h31
dalfab

Bonjour, et bonne année

la data est libérée 2 fois lors de la destruction car elle faite dans ~intarray() mais aussi dans ~extintarray().
01/01/2017, 11h36
hbx360

Bonne année à toi aussi :D, merci beaucoup pour la réponse!
03/01/2017, 10h03
Bousk

- data est propre à intarray, tu ne devrais jamais l'utiliser dans extarray
- en fait tu ne devrais jamais avoir à utiliser des membres de classe mère dans une classe fille
- réinitialiser les pointeurs à nullptr après désallocation aide à limiter ce genre d'étourderie et est souvent une bonne pratique
- les initialiser au départ à nullptr est aussi une bonne pratique
- utiliser vector serait plus sûr que des pointeurs nus qui n'apportent rien ici
- je ne saisie pas la logique du truc, len, alloc ?
- quitte à avoir des pointeurs nus, dans alloc_more autant faire un memcpy ou memmove
04/01/2017, 11h36
Luc Hermitte

Je rajouterai que héritage et copie ne font pas bon ménage. Mais alors pas du tout.
A noter aussi que l'affectation n'a pas été blindée, et que le code n'est pas const-correct.
14/02/2017, 11h55
hbx360

Merci pour vos réponses ; désolé pour mon message tardif.
@Bousk : len et alloc servent pour un tableau redimensionnable donc alloc c'est l'allocation du tableau on alloue une certaine taille et len c'est le nombre de case du tableau qui sont remplie.
Donc par exemple on peut avoir une alloc de taille 10 donc notre tableau aura 10 case et une len de 7 ou il y aura 7 case d'utiliser ; les 3 dernières case seront vides en faite.

@Luc Hermitte : quand en tu par l'affectation n'a pas été blindée et que le code n'est pas const-correct ?
14/02/2017, 12h22
Luc Hermitte
> qu'entends-tu par l'affectation n'a pas été blindée ?

J'entends que
Code:

1 2 3 4 extarray a1 (....); extarray a2; a2 = a1;
Ne peut que planter. Le problème est traité pour la copie (`extarray A2 = a1;`), mais pas pour l'affectation.

Maintenant à cause de l'héritage, il est impossible d'écrire une affectation correcte. Bref, vire l'héritage public.

> et que le code n'est pas const-correct ?

j'entends que tu ne pourras jamais écrire parce qu'il n'y a aucun const
Code:

1 2 3 4 5 6 7 extarray f() { extarray a (....); return a; } .... std::cout << f();
14/02/2017, 15h47
hbx360

Merci pour ta réponse c'est quand même vachement chelou le C++ c'est vraiment un langage difficile à comprendre je trouve. Le C est quand même plus facile et quand je pense qu'on dit du C que c'est un langage qui est difficile à apprendre.
14/02/2017, 16h04
Luc Hermitte

Tout dépend de ce que tu as besoin de faire. En C, tu as moins de mots pour exprimer plein de choses. En C++ tu as plus de mots. Tu vas apprendre plus vite les mots du C, mais ce n'est pas pour autant que tu vas savoir les manipuler correctement.

PS: const existe aussi en C., et les dangling pointers aussi. Sauf qu'en C++ on ne veut pas gérer des pointeurs à la main, et c'est possible.
14/02/2017, 18h43
hbx360

ok