Attributes Operators Definition in Objective-C

Attributes Operators Definition, Objective-C is the primary programming language you use when writing software for OS X and iOS. It’s a superset of the C programming language and provides object-oriented capabilities and a dynamic runtime. Attributes Operators Definition in Objective-C inherits the syntax, primitive types, and flow control statements of C and adds syntax for defining classes and methods.

Rather than creating an entirely new class to provide minor additional capabilities over an existing class, it’s possible to define a category to add custom behavior to an existing class. You can use a category to add methods to any class, including classes for which you don’t have the original implementation source code.

Attributes Operators Definition, The majority of work in an Objective-C app occurs as a result of objects sending messages to each other. Often, these messages are defined by the methods declared explicitly in a class interface.

Integer types

// Char (1 byte for both 32-bit and 64-bit)
unsigned char anUnsignedChar = 255;
NSLog(@"char size: %zu", sizeof(char));

// Short (2 bytes for both 32-bit and 64-bit)
short aShort = -32768;
unsigned short anUnsignedShort = 65535;
NSLog(@"short size: %zu", sizeof(short));

// Integer (4 bytes for both 32-bit and 64-bit)
int anInt = -2147483648;
unsigned int anUnsignedInt = 4294967295;
NSLog(@"int size: %zu", sizeof(int));

// Long (4 bytes for 32-bit, 8 bytes for 64-bit)
long aLong = -9223372036854775808; // 64-bit
unsigned long anUnsignedLong = 18446744073709551615; // 64-bit
NSLog(@"long size: %zu", sizeof(long));

// Long Long (8 bytes for both 32-bit and 64-bit)
long long aLongLong = -9223372036854775808;
unsigned long long anUnsignedLongLong = 18446744073709551615;
NSLog(@"long long size: %zu", sizeof(long long));

Fixed width integer types

// Exact integer types
int8_t aOneByteInt = 127;
uint8_t aOneByteUnsignedInt = 255;
int16_t aTwoByteInt = 32767;
uint16_t aTwoByteUnsignedInt = 65535;
int32_t aFourByteInt = 2147483647;
uint32_t aFourByteUnsignedInt = 4294967295;
int64_t anEightByteInt = 9223372036854775807;
uint64_t anEightByteUnsignedInt = 18446744073709551615;

// Minimum integer types
int_least8_t aTinyInt = 127;
uint_least8_t aTinyUnsignedInt = 255;
int_least16_t aMediumInt = 32767;
uint_least16_t aMediumUnsignedInt = 65535;
int_least32_t aNormalInt = 2147483647;
uint_least32_t aNormalUnsignedInt = 4294967295;
int_least64_t aBigInt = 9223372036854775807;
uint_least64_t aBigUnsignedInt = 18446744073709551615;

// The largest supported integer type
intmax_t theBiggestInt = 9223372036854775807;
uintmax_t theBiggestUnsignedInt = 18446744073709551615;

Floating Point

// Single precision floating-point (4 bytes for both 32-bit and 64-bit)
float aFloat = 72.0345f;
NSLog(@"float size: %zu", sizeof(float));

// Double precision floating-point (8 bytes for both 32-bit and 64-bit)
double aDouble = -72.0345f;
NSLog(@"double size: %zu", sizeof(double));

// Extended precision floating-point (16 bytes for both 32-bit and 64-bit)
long double aLongDouble = 72.0345e7L;
NSLog(@"long double size: %zu", sizeof(long double));

Preprocessor Directives

Directive	Purpose
#define	Used to define constants or macros that are replaced by the compiler at runtime
#elif	An else if conditional statement
#else	An else conditional statement
#endif	An end if conditional statement
#error	Used to flag an error line in code
#if	An if conditional statement
#ifdef	An if defined conditional statement
#ifndef	An if not defined conditional statement
#import	Imports a header file. This directive is identical to #include, except that it won’t include the same file more than once
#include	Includes a header file
#pragma	Used for commenting code or inhibiting compiler warnings
#undef	Used to undefine and redefine macros
#warning	Used to flag a warning line in code

Classes and Protocols

Directive	Purpose
@class	Declares the names of classes defined elsewhere
@interface	Begins the declaration of a class or category interface
@implementation	Begins the definition of a class or category
@protocol	Begins the declaration of a formal protocol
@required	Declares the methods following the directive as required (default)
@optional	Declares the methods following the directive as optional. Classes implementing this protocol can decide whether to implement an optional method or not and should first check if the method is implemented before sending it a message.
@end	Ends the declaration/definition of a class, category, or protocol

Properties

Directive	Purpose
@property	Declares a property with a backing instance variable
@synthesize	Synthesizes a property and allows the compiler to generate setters/getters for the backing instance variable
@dynamic	Tells the compiler that the setter/getter methods are not implemented by the class itself but somewhere else, like the superclass

Errors

Directive	Purpose
@throw	Throws an exception
@try	Specifies a block of code to attempt
@catch	Specifies what to do if an exception was thrown in the @try block
@finally	Specifies code that runs whether an exception occurred or not

Visibility of Instance Variables

Directive	Purpose
@private	Limits the scope of instance variables specified below it to the class that declares it
@protected	Limits the scope of instance variables specified below it to declaring and inheriting classes
@public	Removes restrictions on the scope of instance variables specified below it
@package	Declares the instance variables following the directive as public inside the framework that defined the class, but private outside the framework (64-bit only)

Others

Directive	Purpose
@selector(method)	Returns the compiled selector that identifies a method
@protocol(name)	Returns the given protocol (an instance of the Protocol class)
@synchronized	Encapsulates code in a mutex lock to ensure that the block of code and the locked object can only be accessed by one thread at a time
@autoreleasepool	Replaces (and is 6 times faster than) the NSAutoreleasePool class
@encode(spec)	Yields a character string that encodes the type structure of spec
@compatibility_alias	Allows you to define an alias name for an existing class.
@defs(classname)	Yields the internal data structure of classname instances
@import	Imports a module and autolinks its framework (currently for Apple frameworks only)

Literals

Syntax	What it does
@”string”	Returns an NSString object
@28, @3.14, @YES	Returns an NSNumber object initialized with an appropriate class constructor, depending on the type
@[]	Returns an NSArray object
@{}	Returns an NSDictionary object
@()	Dynamically evaluates the boxed expression and returns the appropriate object literal based on its value

Arithmetic Operators

Operator	Purpose
+	Addition
–	Subtraction
*	Multiplication
/	Division
%	Modulo

Relational and Equality Operators

Operator	Purpose
==	Equal to
!=	Not equal to
>	Greater than
<	Less than
>=	Greater than or equal to
<=	Less than or equal to

Logical Operators

Operator	Purpose
!	NOT
&&	Logical AND
||	Logical OR

Compound Assignment Operators

Operator	Purpose
+=	Addition
-=	Subtraction
*=	Multiplication
/=	Division
%=	Modulo
&=	Bitwise AND
|=	Bitwise Inclusive OR
^=	Exclusive OR
<<=	Shift Left
>>=	Shift Right

Increment and Decrement Operators

Operator	Purpose
++	Addition
—	Subtraction
*=	Multiplication
/=	Division
%=	Modulo
&=	Bitwise AND
|=	Bitwise Inclusive OR
^=	Exclusive OR
<<=	Shift Left
>>=	Shift Right

Bitwise Operators

Operator	Purpose
&	Bitwise AND
|	Bitwise Inclusive OR
^	Exclusive OR
~	Unary complement (bit inversion)
<<	Shift Left
>>	Shift Right

Other operators

Operator	Purpose
()	Cast
? :	Conditional
&	Memory Address
*	Pointer

Property Attributes

Type	What it does
copy	Creates an immutable copy of the object upon assignment and is typically used for creating an immutable version of a mutable object. Use this if you need the value of the object as it is at this moment, and you don’t want that value to reflect any future changes made by other owners of the object.
assign	Generates a setter which assigns the value directly to the instance variable, rather than copying or retaining it. This is typically used for creating properties for primitive types (float, int, BOOL, etc).
weak	Variables that are weak can still point to objects but they do not become owners (or increase the retain count by 1). If the object’s retain count drops to 0, the object will be deallocated from memory and the weak pointer will be set to nil. It’s best practice to create all delegates and IBOutlet’s as weak references since you do not own them.
unsafe_unretained	An unsafe reference is similar to a weak reference in that it doesn’t keep its related object alive, but it won’t be set to nil if the object is deallocated. This can lead to crashes due to accessing that deallocated object and therefore you should use weak unless the OS or class does not support it.
strong	This is the default and is required when the attribute is a pointer to an object. The automatically generated setter will retain (i.e. increment the retain count of) the object and keep the object alive until released.
readonly	This only generates a getter method so it won’t allow the property to be changed via the setter method.
readwrite	This is the default and generates both a setter and a getter for the property. Often times, a readonly property will be publicly defined and then a readwrite for the same property name will be privately redefined to allow mutation of the property value within that class only.
atomic	This is the default and means that any access operation is guaranteed to be uninterrupted by another thread and is typically slower in performance to use.
nonatomic	This is used to provide quicker (but thus interruptable) access operations.
getter=method	Used to specify a different name for the property’s getter method. This is typically done for boolean properties (e.g. getter=isFinished)
setter=method	Used to specify a different name for the property’s setter method. (e.g. setter=setProjectAsFinished)

Extending Classes

Approach	Difficulty	Purpose
Inheritance	Easy	Used if all you want to do is inherit behavior from another class, such as NSObject
Category	Easy	Used if all you need to do is add additional methods to that class. If you also need to add instance variables to an existing class using a category, you can fake this by using associative references.
Delegation	Easy	Used to allow one class to react to changes in or influence behavior of another class while minimizing coupling.
Subclass	Can be difficult	Used if you need to add methods and properties to an existing class or if you want to inherit behavior from an existing class. Some classes are not designed to be subclassed.
Swizzle	Can be difficult	Swizzling allows you to replace a method in an existing class with one of your own making. This approach can lead to a lot of unexpected behavior, so it should be used very sparingly.

Attributes Operators Definition, Happy Coding 🙂