C++

Forum

 
tiny_malloc error? Urgent please !!

Pages: 1234
jimc (62)

Nothing is standing out from the code you have posted. The resize(0) in your copy constructor is unnecessary, but doesn't seem like it would cause any issues. Using an initializer list would probably be more efficient, but just using assignments should still work.

You no longer have Poblacion in your backtrace. Perhaps something in Algoritmo or Individuo leading up to this... I need to get some sleep; been up most of the night.
Phass (48)
I leave here my project. If someone wants to take a look and help me, I'll be infinitely grateful ... because it is my final degree project and this error is beyond my understanding .... (There are only 5 files)

http://dl.dropbox.com/u/816233/Project.zip

As I said, I'll be infinitely grateful... Thanks to all.. :(
Last edited on
Duthomhas (13200)
When is this due?

It will take a little looking over. Your code structure is a little mixxed, and you've got a few unorthodox things in there (like unnecessary gotos that will lose you points with your professor).

Also, I don't know anything about symbolic regression, so I'll have to learn a little about it before I can properly analyze your code -- should I need to peruse it that thoroughly.

It might take me a few days before I can get to it.
simeonz (490)
I have no access to a Mac platform, although it may not be relevant. I can't understand a word of Spanish (is it?). I am not sure how to reproduce the problem. I mean, the program is highly parametrized.

On the positive side, I noticed that the g++ compiler spat quite a few warnings. The most important seem to be that the controlling conditions of your loops compare signed with unsigned expressions. In most cases it looks harmless, but in some, I'm not sure. It may be nothing, but have a look at the bold ones to confirm that they are ok. In fact, it would be best to convert the result from vector::size to signed in all the cases where it appears in the comparison expressions.

In file included from ..\Project\main_con_SLP_punto_H.cpp:7:0:

..\Project\/SLP.H: In constructor 'SLP::SLP(int, int)':

..\Project\/SLP.H:86:7: warning: 'SLP::n_variables' will be initialized after

..\Project\/SLP.H:83:7: warning: 'int SLP::max_operations_L'

..\Project\/SLP.H:122:1: warning: when initialized here

..\Project\/SLP.H: In member function 'float SLP::Calcula_Output(const std::vector<float>&, const std::vector<bool>&, const std::vector<float>&)':

..\Project\/SLP.H:255:55: warning: comparison between signed and unsigned integer expressions

..\Project\/SLP.H:264:55: warning: comparison between signed and unsigned integer expressions

..\Project\/SLP.H:293:39: warning: comparison between signed and unsigned integer expressions

..\Project\/SLP.H:299:56: warning: comparison between signed and unsigned integer expressions

..\Project\/SLP.H: In member function 'float SLP::Calcula_Operando_Variables(int, const std::vector<float>&, const std::vector<float>&)':

..\Project\/SLP.H:325:20: warning: comparison between signed and unsigned integer expressions

In file included from ..\Project\main_con_SLP_punto_H.cpp:8:0:

..\Project\/Individuo.H: In constructor 'Individuo::Individuo(int, int, float, float)':

..\Project\/Individuo.H:94:16: warning: 'Individuo::max_operations_L' will be initialized after

..\Project\/Individuo.H:85:9: warning: 'float Individuo::limite_inferior'

..\Project\/Individuo.H:121:1: warning: when initialized here

In file included from ..\Project\main_con_SLP_punto_H.cpp:9:0:

..\Project\/Poblacion.H: In member function 'void Poblacion::Calcula_Fitness_Poblacion(std::string, const int&, SLP)':

..\Project\/Poblacion.H:212:37: warning: comparison between signed and unsigned integer expressions

..\Project\/Poblacion.H: In member function 'Individuo Poblacion::Mejor_Individuo()':

..\Project\/Poblacion.H:296:38: warning: comparison between signed and unsigned integer expressions

..\Project\/Poblacion.H:304:38: warning: comparison between signed and unsigned integer expressions

..\Project\/Poblacion.H: In member function 'int Poblacion::K_Torneo(int)':

..\Project\/Poblacion.H:349:42: warning: comparison between signed and unsigned integer expressions

..\Project\/Poblacion.H: In member function 'int Poblacion::Ruleta()':

..\Project\/Poblacion.H:363:38: warning: comparison between signed and unsigned integer expressions

..\Project\/Poblacion.H:370:39: warning: comparison between signed and unsigned integer expressions

..\Project\/Poblacion.H:389:39: warning: comparison between signed and unsigned integer expressions

..\Project\/Poblacion.H:399:39: warning: comparison between signed and unsigned integer expressions

..\Project\/Poblacion.H: In member function 'void Poblacion::Cruce_1_punto_selectivo(Individuo&, Individuo&, Individuo&, Individuo&, SLP)':

..\Project\/Poblacion.H:519:46: warning: comparison between signed and unsigned integer expressions

..\Project\/Poblacion.H: In member function 'void Poblacion::Cruce_uniforme(Individuo&, Individuo&, Individuo&, Individuo&)':

..\Project\/Poblacion.H:585:44: warning: comparison between signed and unsigned integer expressions

..\Project\/Poblacion.H:594:42: warning: comparison between signed and unsigned integer expressions

..\Project\/Poblacion.H:617:44: warning: comparison between signed and unsigned integer expressions

..\Project\/Poblacion.H:633:42: warning: comparison between signed and unsigned integer expressions

..\Project\/Poblacion.H: In member function 'void Poblacion::Cruce_uniforme_selectivo(Individuo&, Individuo&, Individuo&, Individuo&, SLP)':

..\Project\/Poblacion.H:660:52: warning: comparison between signed and unsigned integer expressions

..\Project\/Poblacion.H:713:44: warning: comparison between signed and unsigned integer expressions

..\Project\/Poblacion.H:791:57: warning: comparison between signed and unsigned integer expressions

..\Project\/Poblacion.H: In member function 'void Poblacion::Mutacion(Individuo&)':

..\Project\/Poblacion.H:820:6: warning: unused variable 'prob_real'

In file included from ..\Project\main_con_SLP_punto_H.cpp:10:0:

..\Project\/Algoritmo.H: In constructor 'Algoritmo::Algoritmo(int, int, int, float, float, std::string, int, int, int, int, float, float, int, int)':

..\Project\/Algoritmo.H:234:42: warning: comparison between signed and unsigned integer expressions

..\Project\/Algoritmo.H:377:48: warning: comparison between signed and unsigned integer expressions

..\Project\/Algoritmo.H:399:48: warning: comparison between signed and unsigned integer expressions

..\Project\/Algoritmo.H:486:46: warning: comparison between signed and unsigned integer expressions

..\Project\/Poblacion.H: In member function 'int Poblacion::Ruleta()':

..\Project\/Poblacion.H:409:1: warning: control reaches end of non-void function

..\Project\/Poblacion.H: In member function 'int Poblacion::K_Torneo(int)':

..\Project\/Poblacion.H:354:1: warning: control reaches end of non-void function

..\Project\/Poblacion.H: In member function 'Individuo Poblacion::Mejor_Individuo()':

..\Project\/Poblacion.H:312:1: warning: control reaches end of non-void function


EDIT: Switched the boldness of two lines, as I bold-ed those two incorrectly by mistake.
Last edited on
Phass (48)
what does it mean...

warning: 'variable' will be initialized after

&

warning: when initialized here


About to 'warning: comparison between signed and unsigned integer expressions' it's always in a for.. when i < vector.size().... :S

simeonz (490)
The initialization warnings mean that you have different order of construction in the member initialization list in the constructor from the order in which the members were actually declared in the class definition. In these cases the order of declaration for the members dictates the order of their initialization, although the constructors and arguments that you requested are still used.

As an example (stolen from google):
1
2
3
4
5
6
 
struct C
{
  int a, b;
  C() : b(0), a(0) {}

};
initializes first a then b, despite that they are in reverse order in the constructor's member initialization list. This is problem only if one initialization depends on the the result/effect from another one. I think, this is not your case.

As for the signed and unsigned value mismatch, I have put one line in bold that I didn't mean to, but I'll fix it. Anyways, the most suspect comparisons are in bold in the above list. Generally, whenever in an expression dealing with integers and less expressive types (char, short), even one of the operands is unsigned, everything has to be converted to unsigned. If all values are non-negative, this is not a problem, as indeed is the case with most of your comparisons. In most cases the signed number in your code is a non-negative counter.

But this statement in your code, for example, has questionable results:
 
 
for (int j = 0; j < (tamanio_Ui/2)-components.size(); j++)
, because (tamanio_Ui/2)-components.size() is not certainly non-negative unless this is guaranteed by the logic of the code. Check it out. It is enough to become even -1, and it will cause a near infinite loop. Converting -1 to unsigned integer results in the value 0xFFFF...

The others are very similar. You should check that the right side of the comparison will be non-negative. Alternatively, you can convert the result from vector::size to signed int and then you will not need to check anything.
Phass (48)
Ok, I'm going to check if (tamanio_Ui/2)-components.size() could be negative.

I have to thank you and Duoas to spend your time with me .... Thanks!
Phass (48)
I think it's not possible that (tamanio_Ui/2)-components.size() because (tamanio_Ui/2) will always have at least components.size() + 1

(because tamanio_Ui has ('components' + previosly Ui's) of size... Example:

we have 4 components y we are in U2..

1) (4 (x, y, z, w) + 1 (U1)) * 2 (we have 2 operands)

2) tamanio_Ui / 2 --> 5

3) components.size() ---> 4

4) (tamanio_Ui/2)-components.size() > 0

So i think it's not possible that his comparison could be negative

(I'm going crazy :( )
Last edited on
simeonz (490)
Try to cast the result from vector<..>::size() in the above three lines to signed integer. That is:
 
 
for (int j = 0; j < (tamanio_Ui/2)-(int)components.size(); j++)
for the first two lines in bold (SLP.H: line 255 and line 264), and
 
 
for (int i = 0; i < tamanio_output - (int)components.size(); i++)
for the last line in bold (SLP.H: line 299).
Last edited on
Phass (48)
OK I did it... i think there's a problem with 2 first loops in Poblacion :: Ruleta () (357)... there's something strange with 'temp' or something like this, and sometimes there's a infinite loop :S

Any idea looking at the function??

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
 
int Poblacion :: Ruleta ()
{
	float F = 0.0;
	
	for (int i = 0; i < population.size(); i++)
		F += population[i].fitness;
	
	vector<float> fitness_aux (population.size(), 0.0);
	
	for (int i = 0; i < fitness_aux.size(); i++)
	{
		float temp = F - population[i].fitness;
		fitness_aux[i] = temp;
		
	}
	
	float F_aux = 0.0;
	
	for (int i = 0; i < fitness_aux.size(); i++)
		F_aux += fitness_aux[i];
	
// Random number
        float aleatorio = population[0].Numeros_Aleatorios_Entre_a_y_b (0, F_aux);
	
	float contador = 0.0;
	
	for (int i = 0; i < fitness_aux.size(); i++)
	{
		contador += fitness_aux[i];
		
		if (contador >= aleatorio)
		{
			return i;
		}
		
	}
}


(I've executed my code a few times and didn't appear the tiny_malloc error, but I've got to do more executions to check it out correctly...)
Last edited on
simeonz (490)
Your snippet appears ok to me. At least, it seems unlikely to cause infinite loop
Phass (48)
it's so strange, when i debug.... the back trace is

1
2
3
4
5
6
7
 
0  0x00009e42 in __gnu_cxx::operator-<Individuo const*, Individuo const*, std::vector<Individuo, std::allocator<Individuo> > > (__lhs=@0xbffff3ec, __rhs=@0xbffff3e8) at stl_iterator.h:759
#1  0x0000adc2 in std::vector<Individuo, std::allocator<Individuo> >::size (this=0xbffff5cc) at stl_vector.h:403
#2  0x00002b5c in Poblacion::Ruleta (this=0xbffff5cc) at Poblacion.H:360
#3  0x00005b1d in Algoritmo::Algoritmo (this=0xbffff8c4, var=2, ops_L=8, pob=100, inf=-0.150000006, sup=0.75, fich=@0xbffff94c, sel=1, cru=2, mut=1, rep=1, pc=0.899999976, pm=0.100000001, tp=300, el=1) at Algoritmo.H:251
#4  0x00006ae9 in Algoritmo::Algoritmo (this=0xbffff8c4, var=2, ops_L=8, pob=100, inf=-0.150000006, sup=0.75, fich=@0xbffff94c, sel=1, cru=2, mut=1, rep=1, pc=0.899999976, pm=0.100000001, tp=300, el=1) at Algoritmo.H:498
#5  0x00008deb in main () at main_con_SLP_punto_H.cpp:308


temp is always 'inf' and the execution doesn't continue... stops in a loop :S

Last edited on
simeonz (490)
The value of temp does not affect the test condition of the loop. That temp is infinite may be improper, but that shall not cause changes in the behavior of the loop.
Phass (48)
Another thing... why this code always inserts me the same number? It has to insert in a vector the 2 smallest numbers :s

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
 
class="centertext">vector<float> f;
f.push_back (hominum.population[father1].fitness);
f.push_back (hominum.population[father2].fitness);
f.push_back (hijo1.fitness);
f.push_back (hijo2.fitness);
									
float best;
best = * min_element (f.begin(), f.end());
																		
for (int i = 0; i < k.population.size(); i++)
{
    if (k.population[i].fitness == best);
    {
        hominum_aux.population.push_back (k.population[i]);
    }
}

remove (f.begin(), f.end(), best);									
f.resize(3);

float best2;
best2 = * min_element (f.begin(), f.end());
									
for (int i = 0; i < k.population.size(); i++)
{
if (k.population[i].fitness == best2);
   {
       hominum_aux.population.push_back (k.population[i]);
    }
}

Last edited on
Phass (48)
Hi all again... I didn't get solve anything about the stop of the execution... now I did a backtrace-full but I don't understand almost things.... Can you help me?

Simple bt : 

1
2
3
4
5
6
7
 
#0  0x0000b197 in __gnu_cxx::__normal_iterator<double*, std::vector<double, std::allocator<double> > >::__normal_iterator (this=0xbffff408, __i=@0xbffff40c) at stl_iterator.h:603
#1  0x0000b207 in __gnu_cxx::__normal_iterator<double*, std::vector<double, std::allocator<double> > >::operator+ (this=0xbffff43c, __n=@0xbffff438) at stl_iterator.h:654
#2  0x0000b238 in std::vector<double, std::allocator<double> >::operator[] (this=0xbffff488, __n=44) at stl_vector.h:495
#3  0x00005204 in Poblacion::Ruleta (this=0xbffff644) at Poblacion.H:403
#4  0x000057fc in Algoritmo::Algoritmo (this=0xbffff934, var=2, ops_L=7, pob=100, inf=-0.150000006, sup=0.5, fich=@0xbffff9bc, sel=1, cru=1, mut=1, rep=1, pc=0.899999976, pm=0.100000001, tp=100, el=1) at Algoritmo.H:252
#5  0x000067c5 in Algoritmo::Algoritmo (this=0xbffff934, var=2, ops_L=7, pob=100, inf=-0.150000006, sup=0.5, fich=@0xbffff9bc, sel=1, cru=1, mut=1, rep=1, pc=0.899999976, pm=0.100000001, tp=100, el=1) at Algoritmo.H:500
#6  0x00008aa2 in main () at main_con_SLP_punto_H.cpp:304



bt full : 

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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
 
#0  0x0000b197 in __gnu_cxx::__normal_iterator<double*, std::vector<double, std::allocator<double> > >::__normal_iterator (this=0xbffff408, __i=@0xbffff40c) at stl_iterator.h:603
No locals.
#1  0x0000b207 in __gnu_cxx::__normal_iterator<double*, std::vector<double, std::allocator<double> > >::operator+ (this=0xbffff43c, __n=@0xbffff438) at stl_iterator.h:654
No locals.
#2  0x0000b238 in std::vector<double, std::allocator<double> >::operator[] (this=0xbffff488, __n=44) at stl_vector.h:495
No locals.
#3  0x00005204 in Poblacion::Ruleta (this=0xbffff644) at Poblacion.H:403
	i = 44
	fitness_aux = {
  <std::_Vector_base<double,std::allocator<double> >> = {
    _M_impl = {
      <std::allocator<double>> = {
        <__gnu_cxx::new_allocator<double>> = {<No data fields>}, <No data fields>}, 
      members of std::_Vector_base<double,std::allocator<double> >::_Vector_impl: 
      _M_start = 0x803600, 
      _M_finish = 0x803920, 
      _M_end_of_storage = 0x803920
    }
  }, <No data fields>}
	F_aux = -nan(0x8000000000000)
	contador = -nan(0x8000000000000)
	F = -nan(0x8000000000000)
	aleatorio = -nan(0x400000)
#4  0x000057fc in Algoritmo::Algoritmo (this=0xbffff934, var=2, ops_L=7, pob=100, inf=-0.150000006, sup=0.5, fich=@0xbffff9bc, sel=1, cru=1, mut=1, rep=1, pc=0.899999976, pm=0.100000001, tp=100, el=1) at Algoritmo.H:252
	hominum_aux = {
  population = {
    <std::_Vector_base<Individuo,std::allocator<Individuo> >> = {
      _M_impl = {
        <std::allocator<Individuo>> = {
          <__gnu_cxx::new_allocator<Individuo>> = {<No data fields>}, <No data fields>}, 
        members of std::_Vector_base<Individuo,std::allocator<Individuo> >::_Vector_impl: 
        _M_start = 0x0, 
        _M_finish = 0x0, 
        _M_end_of_storage = 0x0
      }
    }, <No data fields>}
}
	n_individuos_nuevos = 0
	diferencia = 0
	straight_line_program = {
  slp = {
    _M_t = {
      _M_impl = {
        <std::allocator<std::_Rb_tree_node<std::pair<const int, std::vector<float, std::allocator<float> > > > >> = {
          <__gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<const int, std::vector<float, std::allocator<float> > > > >> = {<No data fields>}, <No data fields>}, 
        members of std::_Rb_tree<int,std::pair<const int, std::vector<float, std::allocator<float> > >,std::_Select1st<std::pair<const int, std::vector<float, std::allocator<float> > > >,std::less<int>,std::allocator<std::pair<const int, std::vector<float, std::allocator<float> > > > >::_Rb_tree_impl<std::less<int>,false>: 
        _M_key_compare = {
          <> = {<No data fields>}, <No data fields>}, 
        _M_header = {
          _M_color = std::_S_red, 
          _M_parent = 0x100300, 
          _M_left = 0x100320, 
          _M_right = 0x100520
        }, 
        _M_node_count = 8
      }
    }
  }, 
  Uk = {
    <std::_Vector_base<float,std::allocator<float> >> = {
      _M_impl = {
        <std::allocator<float>> = {
          <__gnu_cxx::new_allocator<float>> = {<No data fields>}, <No data fields>}, 
        members of std::_Vector_base<float,std::allocator<float> >::_Vector_impl: 
        _M_start = 0x100420, 
        _M_finish = 0x100440, 
        _M_end_of_storage = 0x100440
      }
    }, <No data fields>}, 
  max_operations_L = 7, 
  n_variables = 2
}
	hominum = {
  population = {
    <std::_Vector_base<Individuo,std::allocator<Individuo> >> = {
      _M_impl = {
        <std::allocator<Individuo>> = {
          <__gnu_cxx::new_allocator<Individuo>> = {<No data fields>}, <No data fields>}, 
        members of std::_Vector_base<Individuo,std::allocator<Individuo> >::_Vector_impl: 
        _M_start = 0x802000, 
        _M_finish = 0x803450, 
        _M_end_of_storage = 0x803450
      }
    }, <No data fields>}
}
	k_t = 1
	mejor = {
  operacion_escalar = {
    <std::_Bvector_base<std::allocator<bool> >> = {
      _M_impl = {
        <std::allocator<std::_Bit_type>> = {
          <__gnu_cxx::new_allocator<std::_Bit_type>> = {<No data fields>}, <No data fields>}, 
        members of std::_Bvector_base<std::allocator<bool> >::_Bvector_impl: 
        _M_start = {
          <std::_Bit_iterator_base> = {
            <> = {<No data fields>}, 
            members of std::_Bit_iterator_base: 
            _M_p = 0x401ac, 
            _M_offset = 262568
          }, <No data fields>}, 
        _M_finish = {
          <std::_Bit_iterator_base> = {
            <> = {<No data fields>}, 
            members of std::_Bit_iterator_base: 
            _M_p = 0x6, 
            _M_offset = 41
          }, <No data fields>}, 
        _M_end_of_storage = 0x0
      }
    }, <No data fields>}, 
  parametros_reales = {
    <std::_Vector_base<float,std::allocator<float> >> = {
      _M_impl = {
        <std::allocator<float>> = {
          <__gnu_cxx::new_allocator<float>> = {<No data fields>}, <No data fields>}, 
        members of std::_Vector_base<float,std::allocator<float> >::_Vector_impl: 
        _M_start = 0x1, 
        _M_finish = 0x0, 
        _M_end_of_storage = 0x0
      }
    }, <No data fields>}, 
  fitness = 0, 
  limite_inferior = 9.18354962e-41, 
  limite_superior = 2.24207754e-44, 
  tamanio = 262185, 
  max_operations_L = -1753700788
}
#5  0x000067c5 in Algoritmo::Algoritmo (this=0xbffff934, var=2, ops_L=7, pob=100, inf=-0.150000006, sup=0.5, fich=@0xbffff9bc, sel=1, cru=1, mut=1, rep=1, pc=0.899999976, pm=0.100000001, tp=100, el=1) at Algoritmo.H:500
No locals.
#6  0x00008aa2 in main () at main_con_SLP_punto_H.cpp:304
	num_variables = 2
	max_ops_L = 7
	tamanio_poblacion = 100
	limite_inferior = -0.150000006
	limite_superior = 0.5
	ruta = {
  static npos = 4294967295, 
  _M_dataplus = {
    <std::allocator<char>> = {
      <__gnu_cxx::new_allocator<char>> = {<No data fields>}, <No data fields>}, 
    members of std::basic_string<char,std::char_traits<char>,std::allocator<char> >::_Alloc_hider: 
    _M_p = 0x1002ec "a.txt"
  }
}
	seleccion = 1
	cruce = 1
	mutacion = 1
	reemplazamiento = 1
	probabilidad_cruce = 0.899999976
	probabilidad_mutacion = 0.100000001
	parada = 100
	elitismo = 1
	regresion_simbolica = {
  n_var = 2, 
  L = 7, 
  t_pob = 100, 
  t_ind = 86, 
  lower = -0.150000006, 
  upper = 0.5, 
  route = {
    static npos = 4294967295, 
    _M_dataplus = {
      <std::allocator<char>> = {
        <__gnu_cxx::new_allocator<char>> = {<No data fields>}, <No data fields>}, 
      members of std::basic_string<char,std::char_traits<char>,std::allocator<char> >::_Alloc_hider: 
      _M_p = 0x1002ec "a.txt"
    }
  }, 
  selection = 1, 
  cross = 1, 
  mutation = 1, 
  replacement = 1, 
  cross_prob = 0.899999976, 
  mutation_prob = 0.100000001, 
  test = 100, 
  elitism = 1, 
  contador = 2, 
  father1 = -1073744721, 
  father2 = -1073744721, 
  father_m = 27, 
  probability = 0.295575738
}


I've got to say that this part of the code works well with low values, but with high values... execution stops :(

Hope you help me again.. it's too important for me to solve it :( thanks

Last edited on
simeonz (490)
The Ruleta() function lacks return statement at the end. You could try adding one as a safeguard for the moment. (Even if you believe that the end of the function is never reached.)
Phass (48)
Ok, but K_Torneo function hasn't got return statement at the end either, and it always returns, never stops the execution :S
simeonz (490)
My point is that you assume that the execution will never proceed after the loop. You probably assume that the return statement inside the loop will be executed, right? The assumption is probably violated because of algorithmic error somewhere else. To verify this, you can check if the program finishes after inserting return statement at the end of Ruleta().

Regards
Phass (48)
I've inserted "return 0" (because the funcion returns an int) but the execution continues stopping in one loop, but i don't know why ... there's one problem assigning values or something like that.... but i don't know.. i don't understand nothing... i don't know why.. :(
Phass (48)
Hey Duoas, have you been looking a little the code to tell me something? I'm really blocked :(
Pages: 1234