එය enum
කුමක්ද සහ එය භාවිතා කළ යුත්තේ කවදාද යන්න මූලික වශයෙන් මට වැටහෙනු ඇතැයි මම නොසිතමි .
උදාහරණයක් වශයෙන්:
typedef enum {
kCircle,
kRectangle,
kOblateSpheroid
} ShapeType;
මෙහි ඇත්ත වශයෙන්ම ප්රකාශයට පත් කරන්නේ කුමක්ද?
එය enum
කුමක්ද සහ එය භාවිතා කළ යුත්තේ කවදාද යන්න මූලික වශයෙන් මට වැටහෙනු ඇතැයි මම නොසිතමි .
උදාහරණයක් වශයෙන්:
typedef enum {
kCircle,
kRectangle,
kOblateSpheroid
} ShapeType;
මෙහි ඇත්ත වශයෙන්ම ප්රකාශයට පත් කරන්නේ කුමක්ද?
Answers:
දේවල් තුනක් මෙහි ප්රකාශ කරනු ඇත: නිර්නාමික ගණනය කිරීමත් වර්ගය ප්රකාශයට පත් කරන්නේ, ShapeType
එම නිර්නාමික ගණනය කිරීම සඳහා typedef ප්රකාශ කරනු ලබන බවට, සහ නම් තුනක් kCircle
, kRectangle
හා kOblateSpheroid
අවියෝජනීය නියතයන් ප්රකාශ කරනු ඇත.
අපි එය බිඳ දමමු. සරලම අවස්ථාවෙහිදී, ගණන් කිරීමක් ලෙස ප්රකාශ කළ හැකිය
enum tagname { ... };
මෙය ටැගය සමඟ ගණන් කිරීමක් ප්රකාශ කරයි tagname
. C සහ Objective-C හි (නමුත් C ++ නොවේ ), මේ පිළිබඳ ඕනෑම සඳහනක් මූලික පදය සමඟ පෙර තිබිය යුතුය enum
. උදාහරණයක් වශයෙන්:
enum tagname x; // declare x of type 'enum tagname'
tagname x; // ERROR in C/Objective-C, OK in C++
enum
සෑම තැනකම යතුරුපදය භාවිතා නොකිරීමට, යතුරු ලියනය සෑදිය හැකිය:
enum tagname { ... };
typedef enum tagname tagname; // declare 'tagname' as a typedef for 'enum tagname'
මෙය එක් පේළියකට සරල කළ හැකිය:
typedef enum tagname { ... } tagname; // declare both 'enum tagname' and 'tagname'
අවසාන වශයෙන්, අපට මූල පදය enum tagname
සමඟ භාවිතා කිරීමට අවශ්ය නොවන්නේ නම් enum
, අපට enum
නිර්නාමිකව සාදා එය ටයිප් කළ නාමයෙන් පමණක් ප්රකාශ කළ හැකිය :
typedef enum { ... } tagname;
දැන්, මේ අවස්ථාවේ දී, අපි ප්රකාශ ShapeType
කරන්නේ නිර්නාමික ගණනය කිරීමක යතුරු ලියනය කළ නමක් ලෙස ය. ShapeType
ඇත්තටම අවියෝජනීය වර්ගය වන අතර, ප්රකාශයට පත් හි ලැයිස්තුගත කර ඇති වටිනාකම් එක් පැවැත්වීමට කරන ප්රකාශ විචල්යයන් (එනම්, එක් කිරීමට පමණක් භාවිතා කළ යුතු kCircle
, kRectangle
සහ kOblateSpheroid
). ShapeType
වාත්තු කිරීමෙන් ඔබට විචල්යයට තවත් අගයක් ලබා දිය හැකිය , එනමුත් එනුම් අගයන් කියවීමේදී ඔබ ප්රවේශම් විය යුතුය.
අවසාන වශයෙන්, kCircle
, kRectangle
, හා kOblateSpheroid
ගෝලීය නාමඅවකාශයෙහි අවියෝජනීය නියතයන් බව ප්රකාශ කරනු ලැබේ. නිශ්චිත අගයන් නිශ්චිතව දක්වා නොමැති හෙයින්, ඒවා 0 සිට ඇරඹෙන අඛණ්ඩ සංඛ්යා වලට අනුයුක්ත වේ, එබැවින් kCircle
0, kRectangle
1, සහ kOblateSpheroid
2 වේ.
ඇපල් විසින් Xcode 4.4 සිට මේ ආකාරයට එනූම් නිර්වචනය කිරීමට නිර්දේශ කරයි :
typedef enum ShapeType : NSUInteger {
kCircle,
kRectangle,
kOblateSpheroid
} ShapeType;
ඔවුන් ඉතා පහසු සාර්වයක් ද සපයයි NS_ENUM
:
typedef NS_ENUM(NSUInteger, ShapeType) {
kCircle,
kRectangle,
kOblateSpheroid
};
මෙම නිර්වචන මගින් වඩා ශක්තිමත් වර්ග පරීක්ෂා කිරීම සහ වඩා හොඳ කේත සම්පූර්ණ කිරීම සපයයි. මට නිල ලියකියවිලි සොයාගත නොහැකි විය NS_ENUM
, නමුත් ඔබට WWDC 2012 සැසියේ "නවීන පරමාර්ථ-සී" වීඩියෝව මෙතැනින් නැරඹිය හැකිය .
යාවත්කාලීන
කිරීම මෙහි නිල ලේඛන වෙත සබැඳිය .
NS_ENUM
සාර්ව පිළිබඳ පැහැදිලි කිරීම එන්එස් හිප්ස්ටර් විසින් බලන්න: NSHipster.com/ns_enum-ns_options
, හෝ kCircle
, විය හැකි අගයන් ඇති පරිශීලක අර්ථ දක්වන ලද වර්ගයකි . එනූම් තුළ ඇති අගයන් (kCircle, ආදිය) එනමුවෙන් පිටත දැකිය හැකිය. එය මතකයේ තබා ගැනීම වැදගත්ය ( වලංගු වේ, උදාහරණයක් ලෙස).kRectangle
kOblateSpheroid
int i = kCircle;
64-බිට් වෙනස සඳහා යාවත්කාලීන කිරීම: බිට් 64 වෙනස්කම් ගැන ඇපල් ලියකියවිලි වලට අනුව ,
ගණනය කිරීම් ද ටයිප් කර ඇත: එල්එල්වීඑම් සම්පාදකයා තුළ, ගණනය කරන ලද වර්ගවලට ගණන් කිරීමේ ප්රමාණය අර්ථ දැක්විය හැකිය. මෙයින් අදහස් කරන්නේ සමහර ගණනය කළ වර්ගවල ඔබ බලාපොරොත්තු වන ප්රමාණයට වඩා විශාල ප්රමාණයක් තිබිය හැකි බවයි. අනෙක් සියලුම අවස්ථා වලදී මෙන් විසඳුම වන්නේ දත්ත වර්ගයක ප්රමාණය පිළිබඳව කිසිදු උපකල්පනයක් නොකිරීමයි. ඒ වෙනුවට, ගණනය කළ අගයන් නිසි දත්ත වර්ගය සමඟ විචල්යයකට පවරන්න
එබැවින් ඔබ 64-බිට් සඳහා සහය දක්වන්නේ නම් පහත සින්ටැක්ස් වර්ගයේ එනුම් වර්ගය සෑදිය යුතුය.
typedef NS_ENUM(NSUInteger, ShapeType) {
kCircle,
kRectangle,
kOblateSpheroid
};
හෝ
typedef enum ShapeType : NSUInteger {
kCircle,
kRectangle,
kOblateSpheroid
} ShapeType;
එසේ නොවුවහොත්, එය අනතුරු ඇඟවීමට තුඩු දෙනු ඇත Implicit conversion loses integer precision: NSUInteger (aka 'unsigned long') to ShapeType
වේගවත් වැඩසටහන්කරණය සඳහා යාවත්කාලීන කිරීම:
වේගයෙන්, සින්ටැක්ස් වෙනසක් ඇත.
enum ControlButtonID: NSUInteger {
case kCircle , kRectangle, kOblateSpheroid
}
සාරධර්ම සමූහයක් (ගණන් බැලීම්) ගණනය කිරීම සඳහා enum (ගණන් කිරීමේ කෙටි යෙදුම) භාවිතා කරයි. අගය යනු සංකේතයක් (වචනයක්) මගින් නිරූපණය කරන වියුක්ත දෙයකි. උදාහරණයක් ලෙස, මූලික එනුම් එකක් විය හැකිය
enum { xs,s,m,l,xl,xxl,xxxl,xxxxl };
ඔබට මෙම නාමය නිර්නාමික ලෙස හැඳින්වෙන්නේ ඔබට එය නම් කිරීමට සංකේතයක් නොමැති බැවිනි. නමුත් එය තවමත් පරිපූර්ණ ලෙස නිවැරදි ය. එය මේ ආකාරයට භාවිතා කරන්න
enum { xs,s,m,l,xl,xxl,xxxl,xxxxl } myGrandMotherDressSize;
හරි. ජීවිතය ලස්සනයි, හැම දෙයක්ම හොඳින් යනවා. නමුත් දිනක් ඔබ myGrandFatherPantSize ගබඩා කිරීම සඳහා නව විචල්යයක් අර්ථ දැක්වීම සඳහා මෙම enum නැවත භාවිතා කළ යුතුය, එවිට ඔබ මෙසේ ලියයි:
enum { xs,s,m,l,xl,xxl,xxxl,xxxxl } myGrandMotherDressSize;
enum { xs,s,m,l,xl,xxl,xxxl,xxxxl } myGrandFatherPantSize;
නමුත් එවිට ඔබට සම්පාදක දෝෂයක් ඇත "ගණන් ගැනීමේ යන්ත්රය නැවත අර්ථ දැක්වීම". ඇත්ත වශයෙන්ම, ගැටළුව වන්නේ සම්පාදකයාට ඔබ මුලින් එන බව විශ්වාස නැති අතර ඔබ දෙවනුව එකම දේ විස්තර කරයි.
ඔබට ස්ථාන කිහිපයකම එකම ගණන් ගැනීමේ කට්ටලයක් නැවත භාවිතා කිරීමට අවශ්ය නම් (මෙහි xs ... xxxxl) ඔබ එය අද්විතීය නමකින් ටැග් කළ යුතුය. දෙවන වරට ඔබ මෙම කට්ටලය භාවිතා කරන විට ඔබට ටැගය භාවිතා කළ යුතුය. නමුත් මෙම ටැගය එන්මුම් වචනය වෙනුවට ප්රතිස්ථාපනය නොකරන බව ගණන් ගන්න එපා. ඉන්පසු සුපුරුදු පරිදි enum භාවිතා කිරීමට සැලකිලිමත් වන්න. මෙවැනි:
// Here the first use of my enum
enum sizes { xs,s,m,l,xl,xxl,xxxl,xxxxl } myGrandMotherDressSize;
// here the second use of my enum. It works now!
enum sizes myGrandFatherPantSize;
ඔබට එය පරාමිති අර්ථ දැක්වීමකින් ද භාවිතා කළ හැකිය:
// Observe that here, I still use the enum
- (void) buyANewDressToMyGrandMother:(enum sizes)theSize;
සෑම තැනකම enum නැවත ලිවීම පහසු නොවන අතර කේතය ටිකක් අමුතු පෙනුමක් ඇති කරයි. ඔයා හරි. සැබෑ වර්ගයක් වඩා හොඳ වනු ඇත.
සමුළුවට අපගේ විශාල ප්රගතියේ අවසාන පියවර මෙයයි. යතුරු ලියනයක එකතු කිරීමෙන් අපගේ එනූමය සැබෑ වර්ගයකට පරිවර්තනය කරමු. ඔහ් අන්තිම දේ, ඔබේ පන්තිය තුළ යතුරු ලියනය කිරීමට අවසර නැත. ඉන්පසු ඔබේ වර්ගය ඉහත අර්ථ දක්වන්න. මේ ආකාරයට කරන්න:
// enum definition
enum sizes { xs,s,m,l,xl,xxl,xxxl,xxxxl };
typedef enum sizes size_type
@interface myClass {
...
size_type myGrandMotherDressSize, myGrandFatherPantSize;
...
}
ටැගය අත්යවශ්ය නොවන බව මතක තබා ගන්න. එතැන් සිට, එවැනි අවස්ථාවක දී, අපි ගණන් කරන්නන් ටැග් නොකර නව වර්ගයක් අර්ථ දැක්වීම සඳහා ය. එවිට අපට එය තවදුරටත් අවශ්ය නොවේ.
// enum definition
typedef enum { xs,s,m,l,xl,xxl,xxxl,xxxxl } size_type;
@interface myClass : NSObject {
...
size_type myGrandMotherDressSize, myGrandFatherPantSize;
...
}
@end
ඔබ XCode සමඟ Objective-C හි සංවර්ධනය කරන්නේ නම් NS_ENUM සමඟ පෙර සැකසූ ලස්සන මැක්රෝස් කිහිපයක් සොයා ගැනීමට මම ඔබට ඉඩ දෙමි. හොඳ එන්මූම් පහසුවෙන් නිර්වචනය කිරීමට එය ඔබට උපකාරී වන අතර එපමණක් නොව, සම්පාදනය කිරීමට පෙර ස්ථිතික විශ්ලේෂකයාට ඔබ වෙනුවෙන් රසවත් චෙක්පත් කිහිපයක් කිරීමට උපකාරී වේ.
හොඳ එනුම්!
typedef
පවතින විචල්ය වර්ගයක නම නැවත අර්ථ දැක්වීම සඳහා ප්රයෝජනවත් වේ. දත්ත සමුදායක් ඇමතීමට එය කෙටි හා අර්ථවත් ක්රමයක් සපයයි. උදා:
typedef unsigned long int TWOWORDS;
මෙහිදී, අත්සන් නොකළ දිගු int වර්ගය TWOWORDS වර්ගයට නැවත අර්ථ දක්වා ඇත. මේ අනුව, අපට දැන් ලිවීමෙන් අත්සන් නොකළ දිගු int වර්ගයේ විචල්යයන් ප්රකාශ කළ හැකිය,
TWOWORDS var1, var2;
වෙනුවට
unsigned long int var1, var2;
typedef enum {
kCircle,
kRectangle,
kOblateSpheroid
} ShapeType;
එවිට ඔබට එය භාවිතා කළ හැකිය: -
ShapeType shape;
සහ
enum {
kCircle,
kRectangle,
kOblateSpheroid
}
ShapeType;
දැන් ඔබට එය භාවිතා කළ හැකිය: -
enum ShapeType shape;
ව්යුහයෙන් කළ නොහැකි enum මූලද්රව්යයන්ට අගය පැවරීමට enum භාවිතා කරයි. එබැවින් සෑම විටම සම්පූර්ණ විචල්යයට ප්රවේශ වීම වෙනුවට අපට එය enum හි විචල්යයන්ට ලබා දෙන අගය අනුව කළ හැකිය. පෙරනිමියෙන් එය 0 පැවරුමකින් ආරම්භ වන නමුත් අපට එයට ඕනෑම අගයක් පැවරිය හැකි අතර එනූම් හි ඊළඟ විචල්යයට පෙර අගය +1 අගය ලබා දෙනු ඇත.
ඔබට පහත ආකෘතියෙන් භාවිතා කළ හැකිය, අමු පෙරනිමි අගය 0 සිට ආරම්භ වේ
ඔබට ඔබේම ආරම්භක අගයක් ලබා දිය හැකිය.
typedef enum : NSUInteger {
kCircle, // for your value; kCircle = 5, ...
kRectangle,
kOblateSpheroid
} ShapeType;
ShapeType circleShape = kCircle;
NSLog(@"%lu", (unsigned long) circleShape); // prints: 0
යතුරු ලියනයක ක්රමලේඛකයාට එක් පරමාර්ථ-සී වර්ගයක් තවත් අර්ථ දැක්වීමට ඉඩ දෙයි. උදාහරණයක් වශයෙන්,
typedef int කවුන්ටරය; කවුන්ටරය වර්ගය int වර්ගයට සමාන යැයි අර්ථ දක්වයි. මෙය කේත කියවීමේ හැකියාව දැඩි ලෙස වැඩි දියුණු කරයි.
ටයිපෙඩෙෆ් යනු සී සහ සී ++ හි යතුරු පදයකි. මූලික දත්ත වර්ග සඳහා (char, int, float, double, struct & enum) නව නම් නිර්මාණය කිරීමට එය භාවිතා කරයි .
typedef enum {
kCircle,
kRectangle,
kOblateSpheroid
} ShapeType;
මෙන්න එය ගණනය කරන ලද දත්ත වර්ගයක් වන ෂේප් ටයිප් නිර්මාණය කරන අතර පහත දැක්වෙන පරිදි අපට එනුම් වර්ගයේ ෂේප් ටයිප් සඳහා නව නම් ලිවිය හැකිය
ShapeType shape1;
ShapeType shape2;
ShapeType shape3;
enum හට බොහෝ ආකාරයේ "දෝෂ" අඩු කර කේතය වඩාත් කළමනාකරණය කළ හැකිය
#define STATE_GOOD 0
#define STATE_BAD 1
#define STATE_OTHER 2
int STATE = STATE_OTHER
අර්ථ දැක්වීමට කිසිදු බාධාවක් නොමැත. එය හුදෙක් ආදේශකයක් පමණි. රාජ්යයේ සියලු කොන්දේසි සීමා කිරීමට එයට නොහැකි ය. STATE 5 ට පවරා ඇති විට, ගැලපෙන තත්වයක් නොමැති නිසා වැඩසටහන වැරදිය. නමුත් සම්පාදකයා STATE = 5 ට අනතුරු ඇඟවීමට යන්නේ නැත
එබැවින් මේ ආකාරයට භාවිතා කිරීම වඩා හොඳය
typedef enum SampleState {
SampleStateGood = 0,
SampleStateBad,
SampleStateOther
} SampleState;
SampleState state = SampleStateGood;