ಎಲ್ಲರಿಗೂ ನಮಸ್ಕಾರ, ಗ್ನು / ಲಿನಕ್ಸ್ನಲ್ಲಿ ಸಿ ++ ಮತ್ತು ಮೈಎಸ್ಕ್ಯೂಎಲ್ ನಡುವಿನ ಸಂಪರ್ಕವು ಹೇಗೆ ಇರುತ್ತದೆ ಎಂಬುದಕ್ಕೆ ನಾನು ಇಲ್ಲಿ ಒಂದು ಉದಾಹರಣೆಯನ್ನು ತರುತ್ತೇನೆ, ಖಂಡಿತ ಇದು ಕೇವಲ ಒಂದು ಮೂಲ ಉದಾಹರಣೆಯಾಗಿದೆ. ಕಂಪೈಲ್ ಮಾಡಲು ಮೊದಲನೆಯದಾಗಿ ನಾನು ಜಿ ++ ಅನ್ನು ಬಳಸಲಿದ್ದೇನೆ ಮತ್ತು ಅವುಗಳು ಪ್ಯಾಕೇಜುಗಳನ್ನು ಸ್ಥಾಪಿಸಿರಬೇಕು libmysql ++ y libmysql ++ - dev . ಇಲ್ಲಿ ಉದಾಹರಣೆ ಇಲ್ಲಿದೆ:
# ಸೇರಿಸಿ # ಸೇರಿಸಿ # ಸೇರಿಸಿ ನೇಮ್ಸ್ಪೇಸ್ ಎಸ್ಟಿಡಿ ಬಳಸಿ; # ಸರ್ವರ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಿ "ಹೋಸ್ಟ್" # ಯುಎಸ್ಇಆರ್ "ಯುಎಸ್ಆರ್" ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಿ # ಪಾಸ್ವರ್ಡ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಿ "ಪಿಎಸ್ಡಬ್ಲ್ಯೂಡಿ" # ಡೇಟಾಬೇಸ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಿ "ಉದಾಹರಣೆ" ಇಂಟ್ ಮುಖ್ಯ () {ಮೈಸ್ಕ್ಯೂಲ್ * ಸಂಪರ್ಕ; connect = mysql_init (NULL); if (! connect) {cout << "MySQL ಪ್ರಾರಂಭಿಕ ವಿಫಲವಾಗಿದೆ"; ರಿಟರ್ನ್ 1; } connect = mysql_real_connect (ಸಂಪರ್ಕಿಸಿ, "HOST", "USER", "PASWD", "DATA BASE", 0, NULL, 0); if (ಸಂಪರ್ಕಿಸಿ) {cout << "ಸಂಪರ್ಕ ಯಶಸ್ವಿಯಾಗಿದೆ \ n"; } else {cout << "ಸಂಪರ್ಕ ವಿಫಲವಾಗಿದೆ \ n"; } MYSQL_RES * res_set; MYSQL_ROW ಸಾಲು; mysql_query (ಸಂಪರ್ಕಿಸಿ, "ಡೇಟಾದಿಂದ * ಆಯ್ಕೆಮಾಡಿ;"); ಸಹಿ ಮಾಡದ ಇಂಟ್ i = 0; res_set = mysql_store_result (ಸಂಪರ್ಕ); ಸಹಿ ಮಾಡದ ಇಂಟ್ ಸಂಖ್ಯೆಗಳು = mysql_num_rows (res_set); cout << endl; cout << "- t -------------------------------------------- ------------------------- \ t "<< endl; while (((ಸಾಲು = mysql_fetch_row (res_set))! = NULL)) {// cout << "% s \ n", ಸಾಲು [i]! = NULL? ಸಾಲು [i]: "NULL"; cout << "\ t | \ t" << ಸಾಲು [i] << "\ t | \ t" << ಸಾಲು [i + 1] << "\ t | \ t" << ಸಾಲು [i + 2] << "\ t | \ t" << endl; cout << "- t -------------------------------------------- ------------------------- \ t "<< endl; } mysql_close (ಸಂಪರ್ಕ); ರಿಟರ್ನ್ 0; }
ಒಳ್ಳೆಯದು, ಜಿ ++ ನಲ್ಲಿ ಕಂಪೈಲ್ ಮಾಡುವುದು ನಿಮಗೆ ತಿಳಿದಿಲ್ಲದಿದ್ದರೆ ಇದು ಒಂದು ಉದಾಹರಣೆ:
g ++ -o main main.cpp -L / usr / include / mysql -lmysqlclient -I / usr / include / mysql
ನಂತರ ನೀವು ಅದನ್ನು ಚಲಾಯಿಸಿ ಮತ್ತು ಅದು ಹೀಗಿರುತ್ತದೆ:
------------------------------------- | 1 | ಕಾರ್ಮೆನ್ | 46 | ------------------------------------- | 2 | ಜುವಾನ್ | 56 | --------------------------------------
ಗಮನಿಸಿ: ನೀವು ಇದನ್ನು MAKEFILE METHOD ಬಳಸಿ ಕಂಪೈಲ್ ಮಾಡಬಹುದು.
ಸಿ ++ ... ಆ ಭಾಷೆ ಬಹಳ ಹಿಂದೆಯೇ ನನ್ನನ್ನು ಸೋಲಿಸಿತು ...
ಆ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಯೊಂದಿಗೆ ನಾನು ಹೆಚ್ಚು ಹಸಿದಿದ್ದೇನೆ (ಅದು ನೀಡುವ ಸ್ಪಷ್ಟತೆ ಮತ್ತು ಸಾಧ್ಯತೆಗಳನ್ನು ಭರಿಸಲಾಗದವು).
ನಾನು ಇಲ್ಲ ಎಂದು ಹೇಳುತ್ತಿಲ್ಲ, ಅದು ನನಗೆ, ಪೈಥಾನ್ ಅಥವಾ ಮೊನೊಗೆ ತುಂಬಾ ಕಷ್ಟಕರವಾದ ಕಾರಣ, ಅವುಗಳನ್ನು ಬಳಸಲು ಸುಲಭವಾಗಿದೆ.
ಪೈಥಾನ್ನೊಂದಿಗೆ ಅಂಟಿಕೊಳ್ಳಿ. ಕಡಿಮೆ ಸಮಯದಲ್ಲಿ ನಿಮ್ಮನ್ನು ಹೆಚ್ಚು ಉತ್ಪಾದಕವಾಗಿಸುತ್ತದೆ.
ಸಾಫ್ಟ್ವೇರ್-ಸೆಂಟರ್ ಅಥವಾ ಯುಬಿಕ್ವಿಟಿಯಂತಹ ಪ್ರೋಗ್ರಾಂಗಳನ್ನು ನಿಧಾನಗೊಳಿಸುವ ದೋಷಗಳನ್ನು ಸರಿಪಡಿಸಲು ಪೈಥಾನ್ ಇರಬಹುದು, ಆದರೆ ಜಾವಾ, ಸಮಯವನ್ನು ಕೊಲ್ಲಲು.
ವಾಸ್ತವವಾಗಿ, ಸಿ ++ ನೊಂದಿಗೆ ನಾನು ಕೋಡ್ಗಳನ್ನು ಉತ್ತಮವಾಗಿ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಬಲ್ಲೆ (ಹೆಚ್ಚಿನವರು ಓದಲಾಗದ ಕೋಡ್ಗಳ ಜಟಿಲವನ್ನು ನೋಡುತ್ತಿದ್ದರೂ) ಮತ್ತು ಅದು ಏನು ಮಾಡಲಿದೆ ಎಂಬುದರ ಬಗ್ಗೆ ನನಗೆ ಸ್ಪಷ್ಟವಾದ ಕಲ್ಪನೆಯನ್ನು ಹೊಂದಬಹುದು (ಜಾವಾ ಮೊದಲ ಬಾರಿಗೆ ಕೋಡ್ ಅನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಸುಲಭವಾದರೂ, ನಾನು ಅದನ್ನು ಬೇಸಿಕ್ ಎಂದು ನೋಡುತ್ತೇನೆ ಮತ್ತು ಸತ್ಯವನ್ನು ಹೇಳಬೇಕೆಂದರೆ, ಒರಾಕಲ್ ಫಕ್ಗಾಗಿ ಹೆಚ್ಚಿನ ದೋಷಗಳನ್ನು ಹಾಕಬಹುದೆಂಬ ಭಯದಿಂದ ಜಾವಾ ಜೆಡಿಕೆ ಬದಲಿಗೆ ಓಪನ್ಜೆಡಿಕೆ ಜೊತೆ ಕೆಲಸ ಮಾಡಲು ನಾನು ಬಯಸುತ್ತೇನೆ).
ನಾನೂ ಕೂಡ
ಧನ್ಯವಾದಗಳು ಸ್ನೇಹಿತ.
ಮೂಲ ಉದಾಹರಣೆ? ನಂತರ ಅದು ಕ್ಲಾಸಿಕ್ ಆಗಿರುತ್ತದೆ:
ವರ್ಗ: 2 + 2 = 4
ಕಾರ್ಯ: 2 × 3 = 6
ಪರೀಕ್ಷೆ: ಎಡ್ವರ್ಡೊಗೆ 20 ಕಿತ್ತಳೆ ಹಣ್ಣುಗಳಿದ್ದರೆ ಮತ್ತು ಅವುಗಳನ್ನು 4 ಮಕ್ಕಳಲ್ಲಿ ವಿತರಿಸಬೇಕಾದರೆ, ಮಕ್ಕಳ ದೇಹದ ದ್ರವ್ಯರಾಶಿ ಎಷ್ಟು?
1.- ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಿ (ಅತ್ಯಂತ ಮುಖ್ಯವಾದ ವಿಷಯ ಮತ್ತು ಅನನುಭವಿಗಳಿಗೆ ನಿಜವಾಗಿಯೂ ಹೆಚ್ಚು ಸಮಯ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ).
2.- ಪರಿಹಾರವನ್ನು ಸಿ ++ ಗೆ ಭಾಷಾಂತರಿಸಿ (ಅದು ಆ ಭಾಷೆಯಾಗಿದ್ದರೆ, ಹೊಸವುಗಳು ಹೆಚ್ಚಿನ ಸಂದರ್ಭಗಳಲ್ಲಿ ಬಿಟ್ಟುಬಿಡುತ್ತವೆ ಮತ್ತು ಗ್ನು ಇಮ್ಯಾಕ್ಸ್ ಅನ್ನು ಬಳಸಿದರೆ ಹೆಚ್ಚು).
3.- ಮುನ್ನೆಚ್ಚರಿಕೆಯಾಗಿ ಡೀಬಗ್ ಮಾಡಿ ಮತ್ತು ಕಂಪೈಲ್ ಮಾಡಿ (ಇದು ನಿಜಕ್ಕೂ ಬೇರೆ ಮಾರ್ಗವಾಗಿದೆ, ಆದರೆ ಕೆಲವರು ಆ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಮಾಡುತ್ತಾರೆ).
ಪಿಎಸ್: ಆ ಪರೀಕ್ಷೆಯು ಆಂಟಿ-ಸ್ಮಗ್ / ಪೆಡಾಂಟಿಕ್ ಆಗಿದೆ.
ಮೂರು ಬಾರಿ ಕಾಮೆಂಟ್ಗೆ ಕ್ಷಮೆಯಾಚಿಸಿದೆ, ಆದರೆ ಪುಟವು ನನಗೆ ಆಂತರಿಕ ಸರ್ವರ್ ದೋಷವನ್ನು ನೀಡಿತು ಮತ್ತು ಬಹುಶಃ ಈ ಕಾರಣದಿಂದಾಗಿ, ಮರುಪ್ರಯತ್ನಿಸುವಾಗ, ಅದನ್ನು ಮತ್ತೆ ಪೋಸ್ಟ್ ಮಾಡಲಾಗಿದೆ.
ಶುಭಾಶಯಗಳು ಮತ್ತು ಪೋಸ್ಟ್ಗೆ ಧನ್ಯವಾದಗಳು !!
ಯಾವ ತೊಂದರೆಯಿಲ್ಲ. ಹೇಗಾದರೂ, ನಾನು ವಿಂಡೋಸ್ಗಾಗಿ ರಾತ್ರಿಯಿಡೀ ಕ್ರೋಮಿಯಂನಲ್ಲಿ ಕಾಮೆಂಟ್ ಮಾಡುತ್ತಿದ್ದೇನೆ ಮತ್ತು ಕಾಮೆಂಟ್ ಮಾಡುವಾಗ ನನಗೆ ಆ ಪ್ರಕೃತಿಯ ಯಾವುದೇ ಸಮಸ್ಯೆಗಳಿಲ್ಲ (ಆದರೂ ನೀವು ನೋಂದಾಯಿಸಲು ಶಿಫಾರಸು ಮಾಡಿದರೂ ಕಾಮೆಂಟ್ ಸಿಸ್ಟಮ್ ವಿಂಡೋಸ್ ಮಿಲೇನಿಯಂಗಿಂತ ಹೆಚ್ಚಿನ ದೋಷಗಳನ್ನು ಎಸೆಯುತ್ತದೆ).
ನಾನು ಹೇಳಲು ಬಯಸಿದ್ದೇನೆ: "ನೀವು ನೋಂದಾಯಿಸಿಕೊಳ್ಳಬೇಕೆಂದು ನಾನು ಶಿಫಾರಸು ಮಾಡಿದರೂ ಕಾಮೆಂಟ್ ಸಿಸ್ಟಮ್ ವಿಂಡೋಸ್ ಮಿಲೇನಿಯಂಗಿಂತ ಕಡಿಮೆ ದೋಷಗಳನ್ನು ಎಸೆಯುತ್ತದೆ" [ತಪ್ಪಾದ ಮಾನವೀಯತೆ].
ಕಾರ್ಪೆ ಡಿಯಮ್ LOL
ಆ ಕೋಡ್ ನಾನು ನೋಡಿದ ಅತ್ಯಂತ ಸುಂದರವಾದ ಸಿ ++ ಆಗಿದೆ (ಕಿಸ್-ಶೈಲಿಯ ಡೇಟಾಬೇಸ್ ವೀಕ್ಷಕ).
ಈಗ, ವಿಂಡೋಸ್ನಲ್ಲಿ ಜಿಸಿಸಿ (ಮೈಎಸ್ಕ್ಯೂಎಲ್ / ಮಾರಿಯಾಡಿಬಿ ಯೊಂದಿಗೆ) ಜೊತೆಯಲ್ಲಿ ಗ್ನು ಇಮ್ಯಾಕ್ಸ್ ಬಳಸಿ ಈ ಕೋಡ್ ಅನ್ನು ವಿಂಡೋಸ್ನಲ್ಲಿ ಸಂಕಲಿಸಬಹುದಾದರೆ, ಅದು ಒಂದು ಮೈಲಿಗಲ್ಲು.
ನಿಸ್ಸಂದೇಹವಾಗಿ, ಸಿ ++ ನಮ್ಮಲ್ಲಿ ಅತ್ಯುತ್ತಮವಾದುದು, ಅದು ನಮಗೆ ನೀಡುವ ಕಾರ್ಯಕ್ಷಮತೆ ಮತ್ತು ಸಾಧ್ಯತೆಗಳ ಬಗ್ಗೆ ಅನಿಯಮಿತ ಸಂಖ್ಯೆಯ ಪರೀಕ್ಷೆಗಳನ್ನು ಮಾಡಿದ್ದೇನೆ ಮತ್ತು ನಿಸ್ಸಂದೇಹವಾಗಿ ಯಾವುದನ್ನೂ ಮೀರಿಸುವುದಿಲ್ಲ, ಖಂಡಿತವಾಗಿಯೂ ಇದು ಕೆಲವರಿಗೆ ತಲೆನೋವಾಗಿರಬಹುದು ಎಂದು ನಾನು ಗುರುತಿಸುತ್ತೇನೆ
ನಾನು ಆ ಭಾಷೆಯನ್ನು ಮೆಚ್ಚುತ್ತೇನೆ, ಆದರೆ ಅದನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ಕರಗತ ಮಾಡಿಕೊಳ್ಳಲು ನನಗೆ ಅಭ್ಯಾಸದ ಕೊರತೆಯಿದೆ (ಮತ್ತು ಸಾಕಷ್ಟು) ಮತ್ತು ಆದ್ದರಿಂದ Qt ಯೊಂದಿಗೆ ಯೋಗ್ಯವಾದ ದೃಶ್ಯ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಒಟ್ಟುಗೂಡಿಸಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ.
ಹುಯ್ ನಂ
ನಾನು ಪೈಥಾನ್ಗೆ ಆದ್ಯತೆ ನೀಡುತ್ತೇನೆ
😀
ಪ್ರತಿಯೊಬ್ಬ ಹುಚ್ಚು ತನ್ನ ಥೀಮ್ ಶುಭಾಶಯಗಳೊಂದಿಗೆ
ಅತ್ಯುತ್ತಮ ಆಯ್ಕೆ.
[ಸ್ವಾರ್ಥ] ಸೋಮಾರಿಯಾದ [/ ಸ್ವಾರ್ಥ].
ನಾನು VB.NET ಗೆ ಆದ್ಯತೆ ನೀಡುತ್ತೇನೆ, ಇದು ತುಂಬಾ ಸುಲಭ ಮತ್ತು SQL ಸರ್ವರ್ಗೆ ಉತ್ತಮ ಬೆಂಬಲವನ್ನು ಹೊಂದಿದೆ. ಇತರ ಭಾಷೆಗಳಿಗಿಂತ ಹೆಚ್ಚು ಉತ್ಪಾದಕವಾಗುವುದರ ಜೊತೆಗೆ ಕೆಲಸ ಹುಡುಕುವಾಗ ಹೆಚ್ಚು ವಿನಂತಿಸಿದ ಒಂದಾಗಿದೆ. ಸಿ ++ ನೊಂದಿಗೆ ನನ್ನ ಸಮಯವನ್ನು ವ್ಯರ್ಥ ಮಾಡಲು ನಾನು ಬಯಸುವುದಿಲ್ಲ
ನಾವು ಇದನ್ನು ಈ ರೀತಿ ಇಟ್ಟರೆ, ಹೆಚ್ಚು ವಿನಂತಿಸಿದ್ದು ಸಾಮಾನ್ಯವಾಗಿ ಜಾವಾದ ಲದ್ದಿ.
ಇದು VB.NET ನಂತೆಯೇ ಇರುತ್ತದೆ, ಆದರೆ ಹೆಚ್ಚು ಚಿತ್ರಾತ್ಮಕವಾಗಿದೆ ಮತ್ತು ಇದು ಗ್ನು / ಲಿನಕ್ಸ್ನಲ್ಲಿ ಕೆಲಸ ಮಾಡಲು ನಿಷ್ಪ್ರಯೋಜಕವಾಗಿದೆ.
ಸಿ ++, ಪೈಥಾನ್ ಮತ್ತು ಕ್ಯೂಟಿ ಮತ್ತು ಬೇಲಿ ಆಶ್ಚರ್ಯಗಳಲ್ಲಿ ಸರಳ ಮಾರಾಟವನ್ನು ರಚಿಸಲು ಸಿ ++ ಬಿ.ಸಿ ಪ್ರೋಬ್ ಅನ್ನು ಮಾತ್ರ ನಾನು ಶಿಫಾರಸು ಮಾಡುತ್ತೇವೆ:
ಪೈಥಾನ್-> 7.6 ಎಮ್ಬಿ
ಕ್ಯೂಟಿ -> 27 ಎಮ್ಬಿ (ಎಕ್ಸ್ಡಿ)
ಸಿ ++ -> 2.4 ಎಮ್ಬಿ
ಪ್ರತಿಯೊಬ್ಬರೂ ತಮ್ಮದೇ ಆದ ತೀರ್ಮಾನಗಳ ಶುಭಾಶಯಗಳನ್ನು ಸೆಳೆಯಲು
ಪೈಥಾನ್ 7.6MB ??? ಆಗುವುದೇ ಇಲ್ಲ! ಅಸಾಧ್ಯ. ಅವರು ಸ್ಕ್ರಿಪ್ಟ್ಗಳಿಗಿಂತ ಹೆಚ್ಚೇನೂ ಇಲ್ಲದಿದ್ದರೆ. ಅಥವಾ ನೀವು ಚಿತ್ರಗಳನ್ನು ಹೊಂದಿದ್ದೀರಾ? ಕೋಡ್ ಹಂಚಿಕೊಳ್ಳಿ. ನಾವೆಲ್ಲರೂ ಇದನ್ನು ನೋಡುತ್ತೇವೆ ಮತ್ತು ಹೋಲಿಸುತ್ತೇವೆ. ನಮಗೆ ಮನವರಿಕೆ ಮಾಡಿ.
ನೀವು ಹೇಳಿದ್ದು ಸರಿ ಸಣ್ಣ ಬಗ್ ಪೈಥಾನ್ 7.6 ಎಮ್ಬಿ ಸೇವಿಸಲಿಲ್ಲ ಆದರೆ 6.2 ಎಮ್ಬಿ ಆಗಿದ್ದರೆ ನೀವು ಈಗ ಹೇಳಿ ...
ಇದು ಕೋಡ್ ಮತ್ತು ಇದನ್ನು ಹೆಚ್ಚು ಹೊಂದುವಂತೆ ಮಾಡಲಾಗುವುದಿಲ್ಲ ಎಂದು ನಾನು ಭಾವಿಸುತ್ತೇನೆ:
#! / usr / bin / python
gi.repository ಆಮದು Gtk ನಿಂದ
win = Gtk.Window ()
win.connect ("ಅಳಿಸು-ಈವೆಂಟ್", Gtk.main_quit)
win.show_all ()
Gtk.main ()
ನೀವು RAM ಬಳಕೆ ಎಂದು ನಾನು imagine ಹಿಸುತ್ತೇನೆ. ವಿಷಯವೆಂದರೆ, ಪೈಥಾನ್ನಲ್ಲಿ ಮತ್ತು ಯಾವುದೇ ಭಾಷೆಯಲ್ಲಿ, ನೀವು ಕೋಡ್ ಅನ್ನು ಸಂಕೀರ್ಣಗೊಳಿಸಿದಾಗ ನೀವು ಲಕ್ಷಣರಹಿತ ಕರ್ವ್ ಅನ್ನು ಅಳೆಯುತ್ತೀರಿ. ಪರೀಕ್ಷೆಗಾಗಿ ನಾನು ಪೈಗೇಮ್ನೊಂದಿಗೆ ಅಭಿವೃದ್ಧಿಪಡಿಸುತ್ತಿರುವ ಆಟವನ್ನು ಓಡಿಸಿದೆ. ಈವೆಂಟ್ಗಳಿಗಾಗಿ ಅನಿಮೇಷನ್ + ಹಿನ್ನೆಲೆ ಆಡಿಯೊ + ಶಬ್ದಗಳು ಮತ್ತು ಕೇವಲ 14MB ತಲುಪಿದೆ. ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ವಿಂಡೋದಂತೆ ಸರಳವಾಗುವುದಿಲ್ಲ ಆದರೆ ಹೆಚ್ಚು ಸಂಕೀರ್ಣವಾಗಿದೆ, ಕೊನೆಯಲ್ಲಿ ನೀವು ನೋಡುತ್ತೀರಿ, ನೀವು ಸಾಕಷ್ಟು ಕೋಡ್ ಹೊಂದಿರುವಾಗ, ಅದರಲ್ಲಿ ದೊಡ್ಡ ಮಾರ್ಪಾಡುಗಳು ನಿಮಗೆ RAM ಬಳಕೆಯಲ್ಲಿ ಹೆಚ್ಚಿನ ಹೆಚ್ಚಳವನ್ನು ತರುವುದಿಲ್ಲ.
ನಾನು ಸ್ವಲ್ಪ ವಿವರಿಸುತ್ತಿರುವುದನ್ನು ಸರಳೀಕರಿಸಲು: ನೀವು ಕೆಲವು ಸಾವಿರ ಬಾರಿ ಕೋಡ್ ಅನ್ನು ಚಲಾಯಿಸದಿದ್ದರೆ ನೀವು ಸಮಯದ ಪ್ರೊಫೈಲ್ ಮಾಡಲು ಸಾಧ್ಯವಿಲ್ಲ, ಅಲ್ಲವೇ? ಒಳ್ಳೆಯದು, ಸಾಧ್ಯವಾದಷ್ಟು ಸರಳವಾದ ಉದಾಹರಣೆಯನ್ನು ನೋಡುವ ಮೂಲಕ ಭಾಷೆ ಬಹಳಷ್ಟು ಅಥವಾ ಸ್ವಲ್ಪವನ್ನು ಬಳಸುತ್ತದೆಯೇ ಎಂದು ನಿಮಗೆ ಹೇಳಲಾಗುವುದಿಲ್ಲ. ವಾಸ್ತವವಾಗಿ, ಟ್ರಿಕ್ ನೀವು ಸಾಧ್ಯವಾದಷ್ಟು ಸಂಕೀರ್ಣವನ್ನು ನೋಡುವುದು.
ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಮಟ್ಟದಲ್ಲಿ ನನ್ನ ತಿಳುವಳಿಕೆಯಲ್ಲಿ ಈ 01010111, ಅಸೆಂಬ್ಲರ್ ಮತ್ತು ನಂತರ ಸಿ, ಆದ್ದರಿಂದ ಅಸಾಧ್ಯವೆಂದರೆ ಪೈಥಾನ್ ನಂತಹ ಉನ್ನತ ಮಟ್ಟದ ಭಾಷೆಯೊಂದಿಗೆ ಅದು ಕಾರ್ಯಕ್ಷಮತೆಯಲ್ಲಿ ಎಸಿ / ಸಿ ++ ಅನ್ನು ಮೀರಿಸುತ್ತದೆ (ಎಲ್ಲಾ ರೀತಿಯಲ್ಲೂ) ಮತ್ತು, ತುಂಬಾ ಸರಳಕ್ಕಿಂತ ಉತ್ತಮವಾದುದು ಸರಳವಾದ ವಿಂಡೋವನ್ನು ತೋರಿಸುವಲ್ಲಿ 3.8 mb ವ್ಯತ್ಯಾಸವನ್ನು ನೋಡಲು ವಿಂಡೋವನ್ನು ರಚಿಸುವಂತಹ ಉದಾಹರಣೆ, ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂಗೆ ನೀವು ಲೋಡ್ ಅನ್ನು ಸೇರಿಸಿದಾಗ (ದೊಡ್ಡ ಪ್ರೋಗ್ರಾಂ, ಅದು 5 ಕ್ಕಿಂತ ಹೆಚ್ಚು ಫಾರ್ಮ್ಗಳೊಂದಿಗೆ ಉತ್ತಮ ತೂಕವನ್ನು ಹೊಂದಿರುತ್ತದೆ ಮತ್ತು ತರಗತಿಗಳು, ಆನುವಂಶಿಕತೆ, ಬಹುರೂಪತೆ, ವರ್ಚುವಲ್ ಕಾರ್ಯಗಳು, ಪಾಯಿಂಟರ್ಗಳು ಮತ್ತು ಹೆಚ್ಚಿನವು ಉದಾಹರಣೆ ನೀಡಲು) ನಿಮ್ಮ ಅಭಿಪ್ರಾಯವನ್ನು ನೀವು ಬದಲಾಯಿಸುವಿರಿ ಎಂದು ನಾನು ನಿಮಗೆ ಭರವಸೆ ನೀಡುತ್ತೇನೆ, ನಾನು ಇತರ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳನ್ನು ಟೀಕಿಸುವುದಿಲ್ಲ ಮತ್ತು ಕ್ಯಾಂಟಾರಿಯೊಗೆ ಪೈಥಾನ್ ಕಡಿಮೆ ಎಂದು ನಾನು ಸ್ಪಷ್ಟಪಡಿಸಲು ಬಯಸುತ್ತೇನೆ, ನಾನು ಮಾತ್ರ ಕಾಮೆಂಟ್ ಮಾಡುತ್ತೇನೆ ಮತ್ತು ಶುಭಾಶಯಗಳನ್ನು ಗಾ to ವಾಗಿಸಲು ಪ್ರೋತ್ಸಾಹವಿಲ್ಲದೆ ನಾನು ಬರಿಗಣ್ಣಿನಿಂದ ನೋಡುವ ಅನುಕೂಲಗಳು ಮತ್ತು ಅನಾನುಕೂಲಗಳನ್ನು ಪರೀಕ್ಷೆಗಳೊಂದಿಗೆ ಪರೀಕ್ಷಿಸಿ
ಇದನ್ನ ನೋಡು:
http://www.youtube.com/watch?v=cPVlYWxcu18
ಆದರೆ ಪೂರ್ಣ ವಿಡಿಯೋ ನೋಡಿ. ಇಲ್ಲದಿದ್ದರೆ ನೀವು ಪೂರ್ವಾಗ್ರಹವನ್ನು ಆಧರಿಸಿ ಅಭಿಪ್ರಾಯವನ್ನು ನೀಡುತ್ತೀರಿ ಎಂದು ಮೋಸ ಮಾಡಬೇಡಿ.
ಯಾವುದೇ ಸಂದರ್ಭದಲ್ಲಿ ನೀವು ನನ್ನನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲಿಲ್ಲ. ನೀವು ವಿಷಯವನ್ನು ಸಂಕೀರ್ಣಗೊಳಿಸಿದಂತೆ, ಎರಡೂ ಹೆಚ್ಚು ಅಥವಾ ಕಡಿಮೆ ಒಂದೇ ತೂಕವನ್ನು ಹೊಂದಿರುತ್ತವೆ. ಲಾಜರಸ್ ಪುಟದಲ್ಲಿ ಅವರು ಲಾಜರಸ್ ಅನ್ನು ಸಿ ಯೊಂದಿಗೆ ಹೋಲಿಸುವ ಮೂಲಕ ಅದರ ಬಗ್ಗೆ ಒಂದು ಗ್ರಾಫ್ ನೀಡುತ್ತಾರೆ.
ಕೊನೆಯಲ್ಲಿ ಎಲ್ಲವೂ ಸಾಪೇಕ್ಷ ಸ್ನೇಹಿತ. ಏಕೆಂದರೆ ಮನುಷ್ಯನು ಕೇವಲ RAM ನಲ್ಲಿ ವಾಸಿಸುವುದಿಲ್ಲ.
ಕನಿಷ್ಠ ಕ್ಯೂಟಿ ಆಕ್ವಾ, ವಿನ್ 32 (ಮತ್ತು ಅವುಗಳ ಏರೋ ಮತ್ತು ಮೆಟ್ರೋ ರೂಪಾಂತರಗಳು) ಇಂಟರ್ಫೇಸ್ಗಳು ಮತ್ತು ಎಲ್ಎಕ್ಸ್ಡಿಇ ಹೊರತುಪಡಿಸಿ ಇತರ ಇಂಟರ್ಫೇಸ್ಗಳೊಂದಿಗೆ ಹೊಂದಿಕೊಳ್ಳುತ್ತದೆ (ಇದು ವಿಂಡೋಸ್ 95 ಪ್ರಾಮಾಣಿಕವಾಗಿ ಕಾಣುತ್ತದೆ).
ಆಕ್ವಾದಲ್ಲಿ gtk2 ಚೆನ್ನಾಗಿ ಕಾಣುತ್ತದೆ ...