Discussion :

[Gear_second]

Salut à tous.
Je viens de terminé un exercice qui me demande de calculer le resultat de la suite de fibonacci d'un nombre entré par l'utilisateur. Mais le nombre que rentre l'utilisateur est de type Bigint un objet . le souci est le suivant : quand je teste pour 1 et 0 cela fonctionne mais pour plus de 1 le programme me renvoie une boite de dialogue comme quoi le programme ne fonctionne pas suite a un problème rencontré.
Merci de bien vouloir m'aider
PS : je developpe sur dev c++ et mon code est le suivant :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
 
#include <iostream>
#include<string>
#include "BigInt.h"
 
BigInt fibo(BigInt x)
{
	BigInt res,vor("0"),nach("1");
	if (x==vor)
		return x;
	if (x==nach)
		return x;
	if (x>1)
	{
		return fibo(x-(nach+nach)) + fibo(x-nach);
	}
}
 
int main()
{
	BigInt zahl,res;
	cout<<"Geben sie einen Zahl ein : ";
	cin>>zahl;
	res=fibo(zahl);
	cout<<"f ( "<<zahl<<" ) : "<<res<<endl;
}

[Bousk]

Salut,

à quoi servent toutes ces variables ?
Si Bigint est un objet, vaudrait mieux le passer en const&
Pour quelle valeur ton "programme ne répond plus" ? Vu que c'est récursif, tu dois faire exploser la callstack
Dev-c++ est obsolète depuis une dizaine d'années, faudrait en changer rapidement

[Daïmanu]

Bonsoir.

La ligne return fibo(x-(nach+nach)) + fibo(x-nach); me semble très compliquée. Elle ne devrait pas plutôt être return fibo(x-"1") + fibo(x-"2"); ?
Et la variable res dans fibo() n'est pas utilisée.

[dalfab]

Bonjour,

Le prototype ou la documentation de BigInt devrait permettre d'y voir clair.

Cependant ( x > 1 ) semblant compiler, je propose de remplacer les deux variables nach et vor par 1 et 0, plutôt que "1" et "0".

[Pierre le Grand]

Il serait utile de savoir de quel bigint.h on parle.

J'ai trouvé celui-ci sur internet. Le constructeur qui prend un string est sans doute utile pour transférer le contenu d'un widget, qui est toujours d'un type chaine de caractères. Cependant, on ne devrait pas l'utiliser par choix par ce qu'il est certainement plus lent que le constructeur qui accepte un int.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
#ifndef _BIGINT_H
#define _BIGINT_H
 
// author: Owen Astrachan
// 8/23/95, modified 7/5/96
//
// implements an arbitrary precision integer class
// 
// constructors:
//
// BigInt()            -- default constructor, value of integers is 0
// BigInt(int n)       -- initialize to value of n (C++ int)
// BigInt(const string & s) -- initialize to value specified by s
//        it is an error if s is an invalid integer, e.g.,
//        "1234abc567".  In this case the bigint value is garbage
// BigInt(const BigInt & b)  -- copy constructor
//
//
// *****  arithmetic operators:
//
// all arithmetic operators +, -, *, /, % are overloaded both
// in form +=, -=, *=, /=, %=, and as binary operators
//
// multiplication and division also overloaded for *= int and /= int
// e.g., BigInt a *= 3 (mostly to facilitate implementation)
//
//  ***** logical operators:
//
// bool operator == (const BigInt & lhs, const BigInt & rhs)
// bool operator != (const BigInt & lhs, const BitInt & rhs)
// bool operator <  (const BigInt & lhs, const BigInt & rhs)
// bool operator <= (const BigInt & lhs, const BigInt & rhs)
// bool operator >  (const BigInt & lhs, const BigInt & rhs)
// bool operator >= (const BigInt & lhs, const BigInt & rhs)
//
//  ***** I/O operators:
//
//  ostream & Print()
//        prints value of BigInt (member function)
//  ostream & operator << (ostream & os, const BigInt & b)
//        stream operator to print value
//
 
 
#include <iostream.h>
#include <string>            // for strings
#include "apvector.h"              // for sequence of digits
 
class BigInt
{
  public:
 
    BigInt();                  // default constructor, value = 0
    BigInt(int);               // assign an integer value
    BigInt(const string &);    // assign a string 
    BigInt(const BigInt &);    // copy constructor
    ~BigInt();                 // destructor
 
    ostream & Print(ostream & os) const;    // so << isn't a friend
 
    BigInt & operator = (const BigInt &);
 
    // operators: arithmetic, relational
 
    BigInt & operator += (const BigInt &);
    BigInt & operator -= (const BigInt &);
    BigInt & operator *= (const BigInt &);
    BigInt & operator *= (int num);
    BigInt & operator /= (const BigInt &);
    BigInt & operator /= (int num);
    BigInt & operator %= (const BigInt &);
 
    string toString() const;   // convert to string
 
    friend bool operator == (const BigInt &, const BigInt &);    
    friend bool operator < (const BigInt &, const BigInt &);
 
  private:
 
    enum BigError{
	underflow, overflow, not_a_number,infinity,no_error
    };
 
    // private state/instance variables
 
    bool myIsNegative;
    apvector<char> myDigits;
    int myNumDigits;
    BigError myError;
 
    // helper functions
 
    bool IsNeg() const;        // return true iff number is negative
    int getDigit(int k) const;
    void addSigDigit(int value);
    void changeDigit(int digit, int value);
    int size() const;
    void Normalize();
    void DivideHelp(const BigInt & lhs, const BigInt & rhs,
		    BigInt & quotient, BigInt & remainder);
 
};
 
// free functions
 
ostream & operator <<(ostream &, const BigInt &);
istream & operator >>(istream &, BigInt &);
 
BigInt operator +(const BigInt & lhs, const BigInt & rhs);
BigInt operator -(const BigInt & lhs, const BigInt & rhs);
BigInt operator *(const BigInt & lhs, const BigInt & rhs);
BigInt operator *(const BigInt & lhs, int num);
BigInt operator *(int num, const BigInt & rhs);
BigInt operator /(const BigInt & lhs, const BigInt & rhs);
BigInt operator /(const BigInt & lhs, int num);
BigInt operator %(const BigInt & lhs, const BigInt & rhs);
 
bool operator != (const BigInt & lhs, const BigInt & rhs);
bool operator >  (const BigInt & lhs, const BigInt & rhs);
bool operator >= (const BigInt & lhs, const BigInt & rhs);
bool operator <= (const BigInt & lhs, const BigInt & rhs);
 
 
#endif   // _BIGINT_H not defined