Utility (C++)
સી + + સ્ટાન્ડર્ડ લાઇબ્રેરીમાં હેડર ફાઇલ છે. આ ફાઇલમાં બે મુખ્ય ઘટકો છેઃ, એક નેમસ્પેસ જેમાં નમૂનાઓનો સમૂહ હોય છે જે રીલેશ્નલ ઓપરેટરો માટે મૂળભૂત વર્તણૂકને વ્યાખ્યાયિત કરે છે, અને વપરાશકર્તા-નિર્ધારિત ઓપરેટરો પર આધારિત સમાન પ્રકારની વસ્તુઓ વચ્ચે અને. એક કન્ટેનર ટેમ્પલેટ જે મનસ્વી પ્રકાર (ઓ) ના બે સભ્ય પદાર્થો (અને) ધરાવે છે. વધુમાં, હેડર એસ માટે મૂળભૂત રીલેશ્નલ ઓપરેટરોને વ્યાખ્યાયિત કરે છે જેમાં બંને પ્રકારો સામાન્ય છે. રીલે _ ઓપ્સ જીસીસીનું અમલીકરણ નેમસ્પેસ (નેસ્ટેડ ઇન) ને નીચેની રીતે જાહેર કરે છેઃ નેમસ્પેસ રીલે _ ઓપ્સ {ટેમ્પલેટ <ક્લાસ _ ટીપી> ઇનલાઇન બૂલ ઓપરેટર! = (કોન્સ્ટ _ ટીપી & _ x, કોન્સ્ટ _ ટીપી & _ _ વાય) {રીટર્ન! (_ _ x = = _ _ y);} ટેમ્પલેટ <ક્લાસ _ ટી. પી.> ઇનલાઇન બૂલ ઓપરેટર> (કોન્સ્ટ _ ટી. પી. & _ x, કોન્સ્ટ _ ટી. પી. & _ y) {રીટર્ન _ _ વાય <_ _ x;} ટેમ્પલેટ <ક્લાસ _ ટી. પી.> ઇનલાઇન બૂલ ઓપરેટર <= (કોન્સ્ટ _ ટી. પી. & _ x, કોન્સ્ટ _ ટી. પી. & _ વાય) {રીટર્ન! (_ _ 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 'બૂલ ઓછા સમાન = (a જો કે, જો સમાન પ્રકાર-વિશિષ્ટ (એટલે કે. નોન-ટેમ્પ્લેટ) ઓપરેટર વર્તમાન અવકાશમાં અસ્તિત્વ ધરાવે છે, વર્ગ વ્યાખ્યાની બહાર પણ, કમ્પાઇલર તેને બદલે પસંદ કરશે. //(ઉપરથી ચાલુ) #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);} જોડી જાહેર કરાયેલ પદાર્થ, ઉદાહરણ તરીકે, જેમાં બે સભ્યો હશે, અને, વત્તા ત્રણ કન્સ્ટ્રક્ટર કાર્યો. પ્રથમ (મૂળભૂત) કન્સ્ટ્રક્ટર બંને સભ્યોને મૂળભૂત મૂલ્યો સાથે પ્રારંભ કરે છે અને, જ્યારે બીજો દરેક પ્રકારનાં એક પરિમાણને સ્વીકારે છે. ત્રીજું એક ટેમ્પ્લેટ કોપી-કન્સ્ટ્રક્ટર છે જે કોઈપણને સ્વીકારશે, જો કે પ્રકારો અને અનુક્રમે ગર્ભિત રૂપાંતર માટે સક્ષમ છે. જી. સી. સી. નું અમલીકરણ પદ્ધતિને નીચે પ્રમાણે વ્યાખ્યાયિત કરે છે. ટેમ્પ્લેટ <ક્લાસ _ T1, ક્લાસ _ T2> સ્ટ્રક્ટ જોડી {ટાઇપેડેફ _ T1 પ્રથમ પ્રકાર; ટાઇપેડેફ _ T2 બીજા પ્રકાર; _ T1 પ્રથમ; _ T2 સેકન્ડ; જોડી (): પ્રથમ (), બીજી () {} જોડી (કોન્સ્ટ _ T1 & _ a, કોન્સ્ટ _ T2 & _ b): પ્રથમ (_ a), બીજી (_ b) {} ટેમ્પલેટ <વર્ગ _ U1, વર્ગ _ U2> જોડી (કોન્સ્ટ જોડી <_ U1, _ U2> & _ p): પ્રથમ (__p.first), બીજા (__p.second) {}); વધુમાં આ હેડર ઉદાહરણો માટે તમામ છ રીલેશ્નલ ઓપરેટર્સને વ્યાખ્યાયિત કરે છે. આ પ્રકારનાં પદાર્થો માટે સખત નબળા ક્રમને વ્યાખ્યાયિત કરે છે, જે ઘટકો પર આધારિત હોય છે અને પછી ઘટકો પર ત્યારે જ હોય છે જ્યારે તે સમાન હોય. //ઉપરના નમૂનાથી ચાલુ <વર્ગ _ T1, વર્ગ _ T2> ઇનલાઇન બૂલ ઓપરેટર = = = (કોન્સ્ટ જોડી <_ T1, _ T2> & _ _ x, કોન્સ્ટ જોડી <_ T1, _ T2> & _ _ y) {રીટર્ન __x.first = = __y.first & & & __x.second = = __y.second;} ટેમ્પલેટ <વર્ગ _ T1, વર્ગ _ T2> ઇનલાઇન બૂલ ઓપરેટર <(કોન્સ્ટ જોડી <_ T1, _ T2> & _ x, કોન્સ્ટ જોડી <_ T1, _ T2> & _ y) {રીટર્ન __x.first <__y.first | (! (__y.first <__x.first) & & __x.second <__y.second);} ટેમ્પલેટ <ક્લાસ _ T1, ક્લાસ _ T2> ઇનલાઇન બૂલ ઓપરેટર! = (કોન્સ્ટ જોડી <_ T1, _ T2> & _ _ x, કોન્સ્ટ જોડી <_ T1, _ T2> & _ _ y) {રીટર્ન! (_ _ 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);} વધુમાં હેડરમાં એક ટેમ્પલેટ-ફંક્શન હોય છે જે પરિમાણોના આધારે તેના વળતરના પ્રકારનો અંદાજ કાઢે છેઃ// ઉપરના ટેમ્પલેટ <ક્લાસ _ T1, ક્લાસ _ T2> ઇનલાઇન જોડી <_ T1, _ T2> મેક _ પેયર (_ T1 _ x, _ T2 _ y) {વળતર જોડી <_ T1, _ T2> (_ _ x, _ _ y);} પણ જુઓ સામાન્ય ઉપયોગિતાઓ માટે બાહ્ય લિંક્સ સંદર્ભ સંદર્ભ સંદર્ભો લાઇબ્રેરી C + + સ્ટાન્ડર્ડ લાઇબ્રેરી