שפת C++ מספקת פונקציה 'pow()' המסייעת במציאת העוצמה של כל מספר. אנו משתמשים בפונקציה זו כאשר אנו רוצים למצוא את עוצמת המספר ב-C++. הפונקציה הזו לוקחת שני ארגומנטים: הארגומנט הראשון הוא ה'בסיס' או המספר שהעוצמה שלו אנחנו רוצים למצוא והארגומנט הבא הוא המעריך בפונקציה הזו. פונקציית 'pow()' זו מוגדרת בתוך קובץ הכותרת 'math.h' או 'cmath' בתכנות C++. בואו נעשה כמה קודים ונבדוק איך שיטה זו מחשבת את העוצמה של מספרים שונים ב-C++.
דוגמה 1:
קובצי הכותרת כלולים תחילה: 'iostream' ו-'cmath'. ה'iostream' נכלל כקלט/פלט ושאר הפונקציות מוגדרות בו. ה-'cmath' נכלל מכיוון שעלינו למצוא את העוצמה של מספר בעזרת הפונקציה 'pow()' המוגדרת בקובץ הכותרת הזה. לאחר מכן, עלינו להוסיף את מרחב השמות 'std' כך שלא נצטרך להוסיף אותו עם הפונקציות בנפרד.
מתחת לזה, אנו מפעילים את שיטת 'main()' ואז מדפיסים טקסט כלשהו באמצעות ה-'cout' מכיוון שהוא מסייע בהדפסה ב-C++. לאחר מכן, אנו משתמשים בפונקציה 'pow()' בה אנו מניחים את '5' כפרמטר הראשון שהוא ה'בסיס' כאן. לאחר מכן, אנו שמים את '3' כפרמטר השני שהוא ה'מעריך' של המספר הזה. כעת, פונקציית ה-'pow()' הזו מוצאת את העוצמה של המספר '5' המוגדלת בחזקת '3' ומציגה את תוצאת העוצמה כשאנו מכניסים את פונקציית ה-'pow()' הזו בתוך ה-'cout'.
קוד 1:
#include
#include
שימוש במרחב שמות std;
int main ( ) {
cout << 'אנחנו מחשבים את כוחו של המספר כאן!' << endl;
cout << פאו ( 5 , 3 ) ;
לַחֲזוֹר 0 ;
}
תְפוּקָה:
התשובה של '5' שהועלתה בחזקת '3' היא '125' אשר מוצגת גם בהמשך. אנו מקבלים את התוצאה הזו בעזרת הפונקציה 'pow()'.
דוגמה 2:
קובצי הכותרת 'iostream' כמו גם 'cmath' כלולים כאן. לאחר מכן, 'מרחב השמות std' ממוקם. מתחת לזה נקרא ה-'main()'. לאחר מכן, אנו מכריזים על שלושה משתנים שהם 'ערך', 'מעריך' ו'תוצאה' כסוג הנתונים 'int'. כעת, אנו מקצים '6' למשתנה 'ערך' ו-'5' למשתנה 'מעריך'.
לאחר מכן, אנו משתמשים בפונקציה 'pow()'. לאחר מכן, אנו מעבירים את שני המשתנים לפונקציית 'pow()' זו ומקצים את התוצאה שלה למשתנה 'outcome'. לאחר מכן, אנו משתמשים ב-'cout' ומדפיסים את ההצהרה כאן תחילה. לאחר מכן, ב'cout' הבא, אנו מציגים את ה'ערך', 'מעריך', כמו גם את 'התוצאה'.
קוד 2:
#include#include
שימוש במרחב שמות std;
int main ( ) {
ערך int, מעריך, תוצאה;
ערך = 6 ;
מעריך = 5 ;
תוצאה = pow ( ערך, מעריך ) ;
cout << 'אנחנו מנצלים את פונקציית הכוח כאן!' << endl;
cout << ערך << '^' << מַעֲרִיך << ' = ' << תוֹצָאָה;
לַחֲזוֹר 0 ;
}
תְפוּקָה:
הפונקציה 'pow()' עוזרת לנו להגיע לתשובה של '6' המוגבלת בחזקת '5' שהיא '7776' כפי שמוצגת בהמשך:
דוגמה 3:
בקוד זה, נמצא את החזקה של המספר הצף כאשר המעריך הוא גם סוג הנתונים הצף. כאן, 'Namespace std' מוכנס לאחר שקובצי הכותרת 'iostream' ו-'cmath' כלולים. לאחר מכן נקראת הפונקציה 'main()', ושלושה משתנים בשם 'n_value', 'e_value' ו-'p_result' מוכרזים כסוג הנתונים 'float'. כעת הגדרנו את המשתנה 'n_value' ל-'8.2' ואת המשתנה 'e_value' ל-'3.2'.
לאחר מכן, אנו משתמשים בפונקציה 'pow()', מעבירים אליה את שני המשתנים ומקצים את הפלט של הפונקציה למשתנה 'p_result'. לאחר מכן, אנו משתמשים בפונקציה 'cout' כדי להדפיס את ההצהרה. ב-'cout' הבא נציג את 'n_value', 'e_value' ו-'p_result' באופן הבא:
קוד 3:
#include#include
שימוש במרחב שמות std;
int main ( ) {
לצוף n_value, e_value, p_result ;
n_value = 8.2 ;
e_value = 3.2 ;
p_result = pow ( n_value, e_value ) ;
cout << 'אנחנו מנצלים את פונקציית הכוח כאן!' << endl;
cout << n_value << '^' << e_value << ' = ' << p_result;
לַחֲזוֹר 0 ;
}
תְפוּקָה:
הנה התוצאה שבה אנו מוצאים את החזקה של מספר הצוף שהמעריך שלו הוא גם המספר הצף בעזרת הפונקציה 'pow()'.
דוגמה 4:
קוד זה מחשב את העוצמה של המספר הכפול עם המעריך כסוג הנתונים הכפול. במקרה זה, קובצי הכותרת 'iostream' ו-'cmath' נכללים לפני ש-'namespace std' נכלל. הקוד הבא קורא לפונקציה 'main()' ומצהיר על שלושה משתנים עם סוג הנתונים 'כפול' ואלו הם 'd_Num', 'd_Expo' ו-'d_PowRes'. המשתנים 'd_num' ו-'d_expo' מאותחלים כעת עם '2.25' ו-'5.21', בהתאמה.
לאחר מכן, אנו מקצים את הפלט של הפונקציה 'pow()' למשתנה 'd_PowRes' ומשתמשים בפונקציה 'pow()', ומעבירים אליו את שני המשתנים. לאחר מכן, נדפיס כאן את המשפט באמצעות הפונקציה 'cout'. ה-'d_Num', 'd_Expo' ו-'d_PowRes' מוצגים ב-'cout' שלאחר מכן.
קוד 4:
#include#include
שימוש במרחב שמות std;
int main ( ) {
כפול d_Num, d_Expo , d_PowRes ;
d_Number = 2.25 ;
d_Expo = 5.21 ;
d_PowRes = pow ( d_Num, d_Expo ) ;
cout << 'אנחנו מנצלים את פונקציית הכוח כאן!' << endl;
cout << 'המספר הוא ' << d_Num << 'המעריך שלו הוא' << d_Expo << endl;
cout << d_Num << '^' << d_Expo << ' = ' << d_PowRes;
לַחֲזוֹר 0 ;
}
תְפוּקָה:
זה נובע משימוש בפונקציה 'pow()' כדי לקבל את החזקה של מספר כפול שגם המעריך שלו הוא מספר כפול.
דוגמה 5:
בקוד אחרון זה, נמצא את החזקה של מספר שהמעריך שלו הוא המספר השלילי. קובצי הכותרת 'bits/stdc++.h' ו-'math.h' כלולים כאן יחד עם קובץ הכותרת 'iostream' בקוד זה, שכן קובץ הכותרת 'math.h' מכיל את ההגדרה של הפונקציה 'pow()'.
לאחר מכן, אנו מוסיפים את מרחב השמות 'std'. לאחר מכן, ה-'main()' נקרא כעת. המשתנה 'b' מאותחל כאן כסוג הנתונים 'צף' והערך '4.87' מוקצה למשתנה זה. מתחת לזה, המשתנה 'int' 'e' מאותחל עם הערך השלילי שהוא '-2'. לאחר מכן, 'תוצאת הציפה' מוצהרת גם כאן. מתחת לזה, אנו מאתחלים את המשתנה 'תוצאה' הזה ומקצים את הפונקציה 'pow()' למשתנה הזה, שבו שני המשתנים 'b' ו-'e' ממוקמים כפרמטרים.
כאן, אנו מכניסים את הבסיס של סוג הנתונים 'צף'. המעריך הוא הערך השלם השלילי. כעת, התוצאה שאנו מקבלים לאחר החלת פונקציה זו נשמרת במשתנה 'תוצאה' המוצג בהמשך באמצעות ה-'cout' שמתחתיו.
קוד 5:
#include#include
#include
שימוש במרחב שמות std;
int main ( ) {
לצוף b = 4.87 ;
int e = -2 ;
תוצאת ציפה;
תוצאה = pow ( ב, ה ) ;
cout << 'המעריך כאן שלילי' << endl;
cout << ב << '^' << זה << ' = ' << תוֹצָאָה;
לַחֲזוֹר 0 ;
}
תְפוּקָה:
זה יוצר את התוצאה שבה אנו מכניסים את המעריך השלילי למספר הבסיס הצף בקוד שלנו. אנו מקבלים את תוצאת העוצמה הזו עם הפונקציה 'pow()'.
סיכום
הפונקציה 'pow()' ב-C++ נחקרת כאן במדריך זה. הגדרנו את זה כמחשוב את ההספק של כל מספר שבו אנו משתמשים בפונקציית 'pow()' הזו. הדגמנו גם מספר דוגמאות ליישום פונקציית 'pow()' זו על המספרים של סוגי נתונים שונים בתכנות C++. חישבנו גם את העוצמה של המספר שבו המעריך הוא הערך השלילי ורינקנו את הפלטים של כל הקוד במדריך זה.