Utility (C++)
ಇದು ಸಿ + + ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಲೈಬ್ರರಿಯಲ್ಲಿರುವ ಹೆಡರ್ ಫೈಲ್ ಆಗಿದೆ. ಈ ಕಡತವು ಎರಡು ಪ್ರಮುಖ ಘಟಕಗಳನ್ನು ಹೊಂದಿದೆಃ, ರಿಲೇಷನಲ್ ಆಪರೇಟರ್ಗಳಿಗೆ ಡೀಫಾಲ್ಟ್ ನಡವಳಿಕೆಯನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವ ಟೆಂಪ್ಲೆಟ್ಗಳ ಗುಂಪನ್ನು ಹೊಂದಿರುವ ನೇಮ್ಸ್ಪೇಸ್, ಮತ್ತು ಬಳಕೆದಾರ-ವ್ಯಾಖ್ಯಾನಿತ ಆಪರೇಟರ್ಗಳ ಆಧಾರದ ಮೇಲೆ ಒಂದೇ ರೀತಿಯ ವಸ್ತುಗಳ ನಡುವೆ. , ಅನಿಯಂತ್ರಿತ ರೀತಿಯ (ಗಳ) ಎರಡು ಸದಸ್ಯ ವಸ್ತುಗಳನ್ನು (ಮತ್ತು) ಹೊಂದಿರುವ ಧಾರಕ ಟೆಂಪ್ಲೇಟ್. ಹೆಚ್ಚುವರಿಯಾಗಿ, ಹೆಡರ್ ಎರಡೂ ರೀತಿಯ ಸಾಮಾನ್ಯತೆಯನ್ನು ಹೊಂದಿರುವ ಎಸ್ಗಳಿಗೆ ಡೀಫಾಲ್ಟ್ ರಿಲೇಷನಲ್ ಆಪರೇಟರ್ಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆ. ರೆಲ್ _ ಓಪ್ಸ್ ಜಿ. ಸಿ. ಸಿ. ಯ ಅನುಷ್ಠಾನವು ನೇಮ್ಸ್ಪೇಸ್ ಅನ್ನು (ನೆಸ್ಟೆಡ್ ಇನ್) ಈ ಕೆಳಗಿನ ರೀತಿಯಲ್ಲಿ ಘೋಷಿಸುತ್ತದೆಃ ನೇಮ್ಸ್ಪೇಸ್ ರೆಲ್ _ ಓಪ್ಸ್ {ಟೆಂಪ್ಲೇಟ್ <ಕ್ಲಾಸ್ _ ಟಿಪಿ> ಇನ್ಲೈನ್ ಬೂಲ್ ಆಪರೇಟರ್! (_ _ x = = _ _ y);} ಟೆಂಪ್ಲೇಟ್ <ಕ್ಲಾಸ್ _ Tp> ಇನ್ಲೈನ್ ಬೂಲ್ ಆಪರೇಟರ್> (ಸ್ಥಿರಾಂಕ _ Tp & _ x, ಸ್ಥಿರಾಂಕ _ Tp & _ y) {ಹಿಂತಿರುಗಿ _ y <_ x;} ಟೆಂಪ್ಲೇಟ್ <ಕ್ಲಾಸ್ _ Tp> ಇನ್ಲೈನ್ ಬೂಲ್ ಆಪರೇಟರ್ <= (ಸ್ಥಿರಾಂಕ _ Tp & _ x, ಸ್ಥಿರಾಂಕ _ Tp & _ y) {ಹಿಂತಿರುಗಿ! (_ _ y <_ _ x);} ಟೆಂಪ್ಲೇಟ್ <ಕ್ಲಾಸ್ _ Tp> ಇನ್ಲೈನ್ ಬೂಲ್ ಆಪರೇಟರ್> = (ಸ್ಥಿರಾಂಕ _ Tp & _ x, ಸ್ಥಿರಾಂಕ _ Tp & _ y) {ಹಿಂತಿರುಗಿ! (_ _ x <_ _ y);}} ಈ ಕೆಳಗಿನ ಘೋಷಣೆಯನ್ನು ಪರಿಗಣಿಸಿ, ಇದು ಒಂದೇ ರೀತಿಯ ಇತರ ವಸ್ತುಗಳ ವಿರುದ್ಧ ಹೋಲಿಕೆ ಮಾಡಲು ಸಮಾನತೆ ಮತ್ತು ಕಡಿಮೆ-ಆಪರೇಟರ್ಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆಃ ವರ್ಗ A {ಪೂರ್ಣಾಂಕ ಕಟ್ಟಡ; ಪೂರ್ಣಾಂಕ ಕೊಠಡಿ; ಸಾರ್ವಜನಿಕಃ ಬೂಲ್ ಆಪರೇಟರ್ = = (ಸ್ಥಿರಾಂಕ A & ಇತರ) ಸ್ಥಿರಾಂಕ {ಹಿಂತಿರುಗಿ (ಕಟ್ಟಡ = = other.building) & & (ಕೊಠಡಿ = = other.room);} ಬೂಲ್ ಆಪರೇಟರ್ <(ಸ್ಥಿರಾಂಕ A & ಇತರ) ಸ್ಥಿರಾಂಕ {ಹಿಂತಿರುಗಿ (ಕಟ್ಟಡ <other.building) | (! (other.building <ಕಟ್ಟಡ) & & (ಕೊಠಡಿ <other.room));}; ಶೂನ್ಯ f1 (ಸ್ಥಿರಾಂಕ A & a1, ಸ್ಥಿರಾಂಕ A & a2) {ಬೂಲ್ ಸಮಾನ = (a1 = = a2);// ಉಪಯೋಗಗಳು = = ವರ್ಗ A ಬೂಲಿನೊಳಗೆ ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ ನಾಟ್ ಸಮಾನ = (a1! = a2);// ದೋಷಃ 'ಆಪರೇಟರ್! =' a1! = a2 'ಬೂಲ್ಗಿಂತ ಕಡಿಮೆ = (a1 <a2);// ವರ್ಗ A ಬೂಲಿನೊಳಗೆ ವ್ಯಾಖ್ಯಾನಿಸಲಾದ ಬಳಕೆಗಳು ದೊಡ್ಡದು = (a1> a2);// ದೋಷಃ' ಆಪರೇಟರ್> 'a1> a2' ಬೂಲ್ಗಿಂತ ಕಡಿಮೆ ಸಮಾನ = (a1) ಆದಾಗ್ಯೂ, ಇದೇ ರೀತಿಯ ನಿರ್ದಿಷ್ಟ (ಅಂದರೆ. ಟೆಂಪ್ಲೇಟ್ ಅಲ್ಲದ) ಆಪರೇಟರ್ ಪ್ರಸ್ತುತ ವ್ಯಾಪ್ತಿಯಲ್ಲಿ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ, ವರ್ಗ ವ್ಯಾಖ್ಯಾನದ ಹೊರಗೂ ಸಹ, ಕಂಪೈಲರ್ ಅದನ್ನು ಆದ್ಯತೆ ನೀಡುತ್ತದೆ. //(ಮೇಲಿನಿಂದ ಮುಂದುವರೆದಿದೆ) #include <ಉಪಯುಕ್ತತೆ> ನೇಮ್ಸ್ಪೇಸ್ ಸ್ಟ್ಯಾಡ್ ಬಳಸಿಃ: ರೆಲ್ _ ಓಪ್ಸ್;// ಕೆಳಗಿರುವ ಆಪರೇಟರ್ ರೆಲ್ _ ಓಪ್ಸ್ ಬೂಲ್ ಆಪರೇಟರ್ ಅನ್ನು ಮೀರಿಸುತ್ತದೆ> = (ಕಾನ್ಸ್ಟ್ A & a1, ಕಾನ್ಸ್ಟ್ A & a2) {ಡು _ ಸಮ್ಥಿಂಗ್ _ ಏಲ್ಸ್ ();// ಕೆಲವು ವಿಶಿಷ್ಟ ಅಡ್ಡ-ಪರಿಣಾಮದ ರಿಟರ್ನ್ ಅನ್ನು ನಿರ್ವಹಿಸಿ! (a1 <a2);// ಆದರೆ ಇಲ್ಲದಿದ್ದರೆ ಅದೇ ವಿಧಾನವನ್ನು ರೆಲ್ _ ಆಪ್ಸ್ನಂತೆ ಬಳಸಿ; ಶೂನ್ಯ f2 (ಕಾನ್ಸ್ಟ್ A & a1, ಕಾನ್ಸ್ಟ್ A & a2) {ಬೂಲ್ ಸಮಾನ = (a1 = = a2);// ಆಪರೇಟರ್ ಅನ್ನು ಬಳಸುತ್ತದೆ = = ವರ್ಗದಲ್ಲಿ ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ A ಬೂಲ್ ಸಮಾನವಲ್ಲ = (a1! = a2);// ಬಳಸುತ್ತದೆ! (a1 = = a2) ಪರ್ ರೆಲ್ _ ಓಪ್ಸ್ ಬೂಲ್ ಲೆಸ್ = (a1 <a2);// ಕ್ಲಾಸ್ A ಬೂಲ್ ಗ್ರೇಟರ್ = (a1> a2);// ಯೂಸ್ (a2 <a1) ಪರ್ ರೆಲ್ _ ಓಪ್ಸ್ ಬೂಲ್ ಲೆಸ್ _ ಈಕ್ವಾಲ್ = (a1 <= a2);// ಯೂಸ್! (a2 <a1) ಪರ್ ರೆಲ್ _ ಓಪ್ಸ್ ಬೂಲ್ ಗ್ರೇಟರ್ _ ಈಕ್ವಲ್ = (a1> = a2);// ಗ್ಲೋಬಲ್ ಆಪರೇಟರ್ ಅನ್ನು ಬಳಸುತ್ತದೆ> = ಮೇಲೆ ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ} ಈ ಕೆಳಗಿನವುಗಳನ್ನು ಸಹಜವಾಗಿ ಘೋಷಿಸಬಹುದು, ಇದು ಎಲ್ಲಾ ರಿಲೇಷನಲ್ ಆಪರೇಟರ್ಗಳ ವ್ಯುತ್ಪತ್ತಿಯನ್ನು ಅನುಮತಿಸುತ್ತದೆಃ ಟೆಂಪ್ಲೇಟ್ <ಕ್ಲಾಸ್ _ Tp> ಇನ್ಲೈನ್ ಬೂಲ್ ಆಪರೇಟರ್ = = (ಸ್ಥಿರಾಂಕ _ Tp & _ x, ಸ್ಥಿರಾಂಕ _ Tp & _ y) {ಹಿಂತಿರುಗಿ! (_ _ x <_ _ y | | _ _ y <_ x);} ಜೋಡಿ ಒಂದು ವಸ್ತುವನ್ನು ಘೋಷಿಸಲಾಗಿದೆ, ಉದಾಹರಣೆಗೆ, ಇದು ಎರಡು ಸದಸ್ಯರನ್ನು ಹೊಂದಿರುತ್ತದೆ, ಮತ್ತು, ಜೊತೆಗೆ ಮೂರು ಕನ್ಸ್ಟ್ರಕ್ಟರ್ ಕಾರ್ಯಗಳನ್ನು ಹೊಂದಿರುತ್ತದೆ. ಮೊದಲ (ಡೀಫಾಲ್ಟ್) ಕನ್ಸ್ಟ್ರಕ್ಟರ್ ಎರಡೂ ಸದಸ್ಯರನ್ನು ಡೀಫಾಲ್ಟ್ ಮೌಲ್ಯಗಳೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸುತ್ತದೆ ಮತ್ತು ಎರಡನೆಯದು ಪ್ರತಿ ಪ್ರಕಾರದ ಒಂದು ನಿಯತಾಂಕವನ್ನು ಸ್ವೀಕರಿಸುತ್ತದೆ. ಮೂರನೆಯದು ಟೆಂಪ್ಲೇಟ್ ಕಾಪಿ-ಕನ್ಸ್ಟ್ರಕ್ಟರ್ ಆಗಿದ್ದು, ಇದು ಯಾವುದೇ ಪ್ರಕಾರವನ್ನು ಸ್ವೀಕರಿಸುತ್ತದೆ, ಒದಗಿಸಿದ ಪ್ರಕಾರಗಳು ಮತ್ತು ಅನುಕ್ರಮವಾಗಿ ಸೂಚ್ಯವಾಗಿ ಪರಿವರ್ತಿಸುವ ಸಾಮರ್ಥ್ಯವನ್ನು ಹೊಂದಿದೆ. ಜಿಸಿಸಿಯ ಅನುಷ್ಠಾನವು ಕಾರ್ಯವಿಧಾನವನ್ನು ಈ ಕೆಳಗಿನಂತೆ ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆ. ಟೆಂಪ್ಲೇಟ್ <ಕ್ಲಾಸ್ _ ಟಿ1, ಕ್ಲಾಸ್ _ ಟಿ2> ಸ್ಟ್ರಕ್ಟ್ ಜೋಡಿ {ಟೈಪ್ಡೆಫ್ _ ಟಿ1 ಮೊದಲ _ ಪ್ರಕಾರ; ಟೈಪ್ಡೆಫ್ _ ಟಿ2 ಎರಡನೇ _ ಪ್ರಕಾರ; _ ಟಿ1 ಮೊದಲ; _ ಟಿ2 ಸೆಕೆಂಡ್; ಜೋಡಿ (): ಮೊದಲ (), ಎರಡನೇ () {} ಜೋಡಿ (ಕಾನ್ಸ್ಟ್ _ ಟಿ1 & _ ಎ, ಕಾನ್ಸ್ಟ್ _ ಟಿ2 & _ ಬಿ): ಮೊದಲ (_ ಎ), ಎರಡನೇ (_ ಬಿ) {} ಟೆಂಪ್ಲೇಟ್ <ಕ್ಲಾಸ್ _ ಯು1, ಕ್ಲಾಸ್ _ ಯು2> ಜೋಡಿ (ಕಾನ್ಸ್ಟ್ ಜೋಡಿ <_ ಯು1, _ ಯು2> & _ ಪಿ): ಮೊದಲ (__p.first), ಎರಡನೇ (__p.second) ಇವುಗಳು ಅಂಶಗಳ ಆಧಾರದ ಮೇಲೆ ಪ್ರಕಾರದ ವಸ್ತುಗಳಿಗೆ ಕಟ್ಟುನಿಟ್ಟಾದ ದುರ್ಬಲ ಕ್ರಮವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತವೆ ಮತ್ತು ನಂತರ ಅಂಶಗಳು ಸಮಾನವಾಗಿದ್ದಾಗ ಮಾತ್ರ ಅವುಗಳ ಮೇಲೆ. //ಮೇಲಿನ ಟೆಂಪ್ಲೇಟ್ನಿಂದ ಮುಂದುವರೆದಿದೆ <ಕ್ಲಾಸ್ _ ಟಿ1, ಕ್ಲಾಸ್ _ ಟಿ2> ಇನ್ಲೈನ್ ಬೂಲ್ ಆಪರೇಟರ್ = = = (ಕಾನ್ಸ್ಟ್ ಜೋಡಿ <_ ಟಿ1, _ ಟಿ2> & _ _ ಎಕ್ಸ್, ಕಾನ್ಸ್ಟ್ ಜೋಡಿ <_ ಟಿ1, _ ಟಿ2> & _ ವೈ) {ರಿಟರ್ನ್ __x.first = = __y.first & & __x.second = = __y.second;} ಟೆಂಪ್ಲೇಟ್ <ಕ್ಲಾಸ್ _ ಟಿ1, ಕ್ಲಾಸ್ _ ಟಿ2> ಇನ್ಲೈನ್ ಬೂಲ್ ಆಪರೇಟರ್ <(ಕಾನ್ಸ್ಟ್ ಜೋಡಿ <_ ಟಿ1, _ ಟಿ2> & _ _ ಎಕ್ಸ್, ಕಾನ್ಸ್ಟ್ ಜೋಡಿ <_ ಟಿ1, _ ಟಿ2> & _ ವೈ) {ರಿಟರ್ನ್ __x.first <__y.first | (! (__y.first <__x.first) & & __x.second <__y.second);} ಟೆಂಪ್ಲೇಟ್ <ಕ್ಲಾಸ್ _ T1, ಕ್ಲಾಸ್ _ T2> ಇನ್ಲೈನ್ ಬೂಲ್ ಆಪರೇಟರ್! (_ _ x = = _ _ y);} ಟೆಂಪ್ಲೇಟ್ <ಕ್ಲಾಸ್ _ T1, ಕ್ಲಾಸ್ _ T2> ಇನ್ಲೈನ್ ಬೂಲ್ ಆಪರೇಟರ್> (ಸ್ಥಿರಾಂಕ ಜೋಡಿ <_ T1, _ T2> & _ _ x, ಸ್ಥಿರಾಂಕ ಜೋಡಿ <_ T1, _ T2> & _ y) {ರಿಟರ್ನ್ _ y <_ x;} ಟೆಂಪ್ಲೇಟ್ <ಕ್ಲಾಸ್ _ T1, ಕ್ಲಾಸ್ _ T2> ಇನ್ಲೈನ್ ಬೂಲ್ ಆಪರೇಟರ್ <= (ಸ್ಥಿರಾಂಕ ಜೋಡಿ <_ T1, _ T2> & _ x, ಸ್ಥಿರಾಂಕ ಜೋಡಿ <_ T1, _ T2> & _ y) {ರಿಟರ್ನ್! (_ _ y <_ _ x);} ಟೆಂಪ್ಲೇಟ್ <ಕ್ಲಾಸ್ _ T1, ಕ್ಲಾಸ್ _ T2> ಇನ್ಲೈನ್ ಬೂಲ್ ಆಪರೇಟರ್> = (ಸ್ಥಿರಾಂಕ ಜೋಡಿ <_ T1, _ T2> & _ _ x, ಸ್ಥಿರಾಂಕ ಜೋಡಿ <_ T1, _ T2> & _ _ y) {ಹಿಂತಿರುಗಿ! (_ _ x <_ _ y);} ಹೆಚ್ಚುವರಿಯಾಗಿ ಹೆಡರ್ ನಿಯತಾಂಕಗಳ ಆಧಾರದ ಮೇಲೆ ಅದರ ರಿಟರ್ನ್ ಪ್ರಕಾರವನ್ನು ಕಂಡುಹಿಡಿಯುವ ಟೆಂಪ್ಲೇಟ್-ಫಂಕ್ಷನ್ ಅನ್ನು ಹೊಂದಿರುತ್ತದೆಃ// ಮೇಲಿನ ಟೆಂಪ್ಲೇಟ್ನಿಂದ ಮುಂದುವರೆದಿದೆ <ಕ್ಲಾಸ್ _ ಟಿ1, ಕ್ಲಾಸ್ _ ಟಿ2> ಇನ್ಲೈನ್ ಜೋಡಿ <_ ಟಿ1, _ ಟಿ2> ಮೇಕ್ _ ಪೇರ್ (_ ಟಿ1 _ x, _ ಟಿ2 _ y) {ರಿಟರ್ನ್ ಜೋಡಿ <_ ಟಿ1, _ ಟಿ2> (_ _ x, _ _ y);} ಸಾಮಾನ್ಯ ಉಪಯುಕ್ತತೆಗಳ ಲೈಬ್ರರಿ ಸಿ + + ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಲೈಬ್ರರಿಗಾಗಿ ಬಾಹ್ಯ ಕೊಂಡಿಗಳು ಸಿ + + ಉಲ್ಲೇಖಗಳನ್ನು ಸಹ ನೋಡಿ