εκθετική μορφή στην C

[kzdev]

πως μπορώ να υψώσω δύναμη σε κάποιον αριθμό στην C

στην basic γινόταν ως εξής:
a = 2 ^ 5

πως γίνεται στην C?

[turboirc]

std::pow() , <cmath> (pow, <math.h>)

[kzdev]

Στην περίπτωση που θέλω απλώς να δηλώσω σταθερά, υπάρχει κάποιος αντίστοιχος τελεστής στην C?

........Auto merged post: kzdev πρόσθεσε 6 λεπτά και 31 δευτερόλεπτα αργότερα ........

ο preprocessor δεν έχει κάποιες αντίστοιχες μακροεντολές για δημιουργία εκθετικής μορφής;

[turboirc]

Οχι απ'οσω ξέρω. Για πιο λόγο ?

const float x = pow(...);

[kzdev]

μου χρειάζεται να ορίσω εκθετική μορφή σε κάποια σταθερά που είναι συνάρτηση άλλης σταθεράς και στο πρόγραμμά μου θέλω να έχει την ακόλουθη μορφή:

//βρίσκεται στο main.c
#define Cnst1    7

//βρίσκεται σε άλλο αρχείο της βιβλιοθήκης μου
#define Cnst2    2 ^ Cnst1
     ....
     a = a >> Cnst1;
  
     ....  
     b++
     if (b>Cnst2)
         do_something();
     ....

τώρα όμως αναγκαστηκά τα ορίζω ως εξής:

//βρίσκεται στο main.c
#define Cnst1    7
#define Cnst2    128    //2 ^ Cnst1

[turboirc]

Για πιο λογο #define ?

[kzdev]

πως αλλιώς θα μπορούσε να γίνει; (αναφέρομαι σε ANSI C)

[turboirc]

const float.

[kzdev]

ok, θα δοκιμάσω αυτο που ανέφερες προηγούμενως:
const float x = pow(...);

thanx.

[bxenos]

εχεις δικιο kzdev οτι ειναι καλυτερα να γινει σε define.

oπως καταλαβες το pow() πιανει χωρο στην μνημη rom (εκτος αν το χρησιμοποιεις και αλλου στο προγραμμα σου, οποτε μια φορα γινετε link) και επιπλεον αρτκετο επεξεργαστικο χρονο.

Αν θελεις να υψωσεις σε δυναμη του 2 εναν ακεραιο:

#define MyConst               121
#define MyConst_2         MyCosnt<<1        //MyConst ^2
#define MyConst_4         MyCosnt<<2        //MyConst ^4
#define MyConst_8         MyCosnt<<3        //MyConst ^8

(γι'αυτο λεω οποιος δεν τα παει καλα με τα μαθηματικα, ας αφησει τη C).

Αν θελεις να υψωσεις οτιδηποτε (ακεραιο,πραγματικο) σε ακεραια δυναμη

#define SQUARE(x)           (x)*(x)
#define CUBE(x)                (x)*SQUARE(x)

#define MyConst                3.523426534
#define MyConst_7           CUBE(MyConst)*CUBE(MyConst)*(MyConst)    //MyConst^7

αυτο φυσικα δεν απαιτει ΚΑΘΟΛΟΥ επεξεργαστικο χρονο αφου γινεται σε επιπεδο compile.
και φυσικα μπορεις να φτιαξεις οποιονδηποτε συνδιασμο απο defines που να υπολογιζουν δυναμη σε οποιοδηποτε εκθετη για ευκολια. Π.χ. αν χρησιμοποιουσα συχνα την υψωση στην δυναμη 11 θα εκανα

#define Pow11(x)          CUBE(x)*CUBE(x)*CUBE(x)*SQUARE(x)

προσοχη:
το

#define xxx 764
double x = Pow11(xxx)

δεν καταναλωνει επεξεργαστικο χρονο καθοτι υπολογιζεται σε compile time

ενω το

const float xxx = 764;
float x = Pow11(xxx);

εκτελει σε run time τουςυπολογισμους.

το παραδειγμα που ανεφερες

//βρίσκεται στο main.c
#define Cnst1    7
#define Cnst2    128    //2 ^ Cnst1

πρεπεινα γινει ετσι

#define TWO_POW(x)          (x==0) ? 1 : (2 << (x-1))     //υψωσε το 2 σε δυναμη

//ή για οσους τα πανε καλυτερα με μαθηματικα και δυαδικο
#define TWO_POW(x)          (1 << (x))   //υψωσε το 2 σε δυναμη (καλυτερη εκδοση)

#define Cnst1                        7
#define Cnst2                       TWO_POW(Cnst1)

τι κανει η TWO_POW?
περνει την παραμετρο χ (εκθετης), αν χ==0 επιστρεφει 1 αλλιως επιστρεφειτο 2 υψωμενο στην δυναμη x (ουσιαστικα το 2 shifted x-1 φορες)

[kzdev]

σε παραδέχομαι και ξέρεις κάτι την τακτική αυτή την χρησιμοποιοώ συνέχεια για ενεργοποίηση bit σε μια μεταβλητή. Δεν μου πέρασε καθόλου απο το μυαλό για χρήση σε ύψωση σε δύναμη αριθμού.

........Auto merged post: kzdev πρόσθεσε 2 λεπτά και 17 δευτερόλεπτα αργότερα ........

MyVar |= (1<<7)

[turboirc]

Το const float φυσικά έχει runtime effect αλλα σήμερα το #define θεωρείται απαρχαιωμένη και επικίνδυνη πρακτική. Οτιδήποτε έχει σχέση με τον preprocessor παρακάμπτει τον compiler και κατά συνέπεια δημιουργεί bugs που είναι πολύ δύσκολο να βρεθούν.

Επιπλέον, η σημερινές υλοποιήσεις του CRT δεν υπολογίζουν πλέον πολλές μαθηματικές συναρτήσεις κάνοντας όντως την πράξη, αλλά από preconfigured tables που έχουν γίνει cache ήδη οι απαντήσεις.

Επιπλέον, ένας καλός compiler θα αντικαταστήσει το const float x = pow(5,6) με το πραγματικό αποτέλεσμα, επομενως δεν έχεις κανένα performance και γλυτώνεις τα προβλήματα της macro.

Τέλος, το << δουλεύει μόνο για δυνάμεις του 2

[bxenos]

Το const float φυσικά έχει runtime effect αλλα σήμερα το #define θεωρείται απαρχαιωμένη και επικίνδυνη πρακτική.
Οτιδήποτε έχει σχέση με τον preprocessor παρακάμπτει τον compiler και κατά συνέπεια δημιουργεί bugs που είναι πολύ δύσκολο να βρεθούν.

λαθος μεγα, αν φοβασε το define, κανε

#define MyConst         ((float) 31)

και να δω τι παρακαμψη θα κανεις μετα...
Τα #define θα ειναι απαρχαιωμενα οταν ερθει η συντελεια του κοσμου.
Δες οποιοδηποτε #include αρχειο, ποσα #define εχει...

Επιπλέον, οι σημερινές υλοποιήσεις του CRT δεν υπολογίζουν πλέον πολλές μαθηματικές συναρτήσεις κάνοντας όντως την πράξη, αλλά από preconfigured tables που έχουν γίνει cache ήδη οι απαντήσεις.

πηγή; Σε μικροελενκτες παντως δεν το θεωρω πιθανο να ισχυει αυτο λογω ελειψης χωρου. Οι πινακες πιανουν πολυ χωρο.
(αλλες υλοποιησεις υπαρχουν αλλα δεν γνωριζω να εχουν ενσωματωθει σε καμια βιβλιοθηκη απο τον κατασκευστη του compiler), αν ξερεις καποια πες μου. Μπορεις αν θελεις να κανεις overwrite σε link time την pow() με αυτη που προανεφερα.

Επιπλέον, ένας καλός compiler θα αντικαταστήσει το const float x = pow(5,6) με το πραγματικό αποτέλεσμα, επομενως δεν έχεις κανένα performance και γλυτώνεις τα προβλήματα της macro.

πηγη; κανενας καλος compiler δεν θα επεμβει!!!. Και δεν νομιζω να υπαρχει κανενας κακος compiler που να το κανει. Αν δηλαδη εγω κανω overwrite σε link time την pow(), o compiler θα αυτοσχεδιαζει και θα καλεσει αυτη που ηξερε μια φορα και εναν καιρο;
Μαλλον εχεις δει για την εκτελεση καποιων inline συναρτησεων σε compile time και μπερδευτηκες. Δεν νομιζω η pow() να ειναι σε οποιαδηποτε υλοποιηση inline.
(τις inline δεν της ενσωματωνει ο linker αλλα ο compiler, αρα δεν μπορω να τις αντικαταστησω σε link time και γι'αυτο ο compiler εχει καποιο οπτιμιζατιον να τις εκτελει οταν ειναι απλες).

Τέλος, το << δουλεύει μόνο για δυνάμεις του 2

ειπα κατι διαφορετικο;οπως ειπα ισχυει μονο για ακεραιους με εκθετες δυναμεις του 2.

........Auto merged post: bxenos πρόσθεσε 13 λεπτά και 32 δευτερόλεπτα αργότερα ........

:MyVar |= (1<<7)

μια που μαθαινεις C να και ενας αλλος τροπος (προσοχη, εχει σημασια αν στο byte αποθηκευοντε LSB ή MSB, σε microchip ισχυει).

typedef union {
              unsigned char b;
              struct {
                         unsigned char bit0 : 1;
                         unsigned char bit1 : 1;
                         unsigned char bit2 : 1;
                         unsigned char bit3 : 1;
                         unsigned char bit4 : 1;
                         unsigned char bit5 : 1;
                         unsigned char bit6 : 1;
                         unsigned char bit7 : 1;
              };
} bytebits;

{
       bytebits flag;
       flag.b = 234;
       //κανε το bit 6 TRUE
        flag.bit6 = TRUE;
        //κανε το bit 3 FALSE
         flag.bit3 = FALSE;
}

//ή το ακομψο

{
        unsigned char flag = 234;
         ((bytebits *)&flag)->bit6 = TRUE;
         ((bytebits *)&flag)->bit3 = FALSE;
}

παρατηρω οτι προχωρας με σωστο τροπο σκεψης...

Off Topic

να και ενας αλλος τροπος να επιστρεφεις πολλες παραμετρους οταν δεν θελεις
να τις περασεις σαν δεικτες στην συναρτηση - τωρα ειδα εκεινο το post σου

typedef struct {
             int x,y;
} point;

point func(int x){
            point a;
            a.x = x;
            a.y = 3 * x + 27;
            return a;
}

οχι οτι ειναι κακη επιλογη οι δεικτες, το αντιθετο μαλιστα, αλλα αλλου βολευει δεικτες (ansi C) (κυριως οταν εχεις ηδη τον αποθηκευτικο χωρο για τα επιστρεφομενα δεσμευμενο) και αλλου οχι (π.χ. C++). Και οι δεικτες και ο παραπανω κωδικας λειτουργουν σε ολες τις C/C++