CodeWorld55

Showing posts with label iPhone. Show all posts

How Use Typedef in Objective-C

The Objective-C programming dialect gives a catchphrase called typedef, which you can use to give a sort another name. Taking after is an illustration to characterize a term BYTE for one-byte numbers:

typedef unsigned char BYTE;

After this sort definition, the identifier BYTE can be utilized as a truncation for the sort unsigned roast, for instance:.

BYTE  b1, b2;

By tradition, uppercase letters are utilized for these definitions to remind the client that the sort name is truly a typical shortening, however you can utilize lowercase, as takes after:

typedef unsigned char byte;

You can utilize typedef to give a name to client characterized information sort too. For instance, you can utilize typedef with structure to characterize another information sort and after that utilization that information sort to characterize structure variables straightforwardly as takes after:

#import <Foundation/Foundation.h>;

typedef struct Books

{

NSString *title;

NSString *author;

NSString *subject;

int book_id;

} Book;

int main( )

{

Book book;

book.title = @"Objective-C Programming";

book.author = @"TutorialsPoint";

book.subject = @"Programming tutorial";

book.book_id = 100;

NSLog( @"Book title : %@\n", book.title);

NSLog( @"Book author : %@\n", book.author);

NSLog( @"Book subject : %@\n", book.subject);

NSLog( @"Book Id : %d\n", book.book_id);

return 0;

}

At the point when the above code is gathered and executed, it delivers the accompanying result:

2013-09-12 12:21:53.745 demo[31183] Book title : Objective-C Programming
2013-09-12 12:21:53.745 demo[31183] Book author : TutorialsPoint
2013-09-12 12:21:53.745 demo[31183] Book subject : Programming tutorial
2013-09-12 12:21:53.745 demo[31183] Book Id : 100

typedef vs #define

The #define is an Objective-C mandate, which is additionally used to characterize the monikers for different information sorts like typedef however with taking after contrasts:

The typedef is limited to giving symbolic names to types only whereas #define can be used to define alias for values as well, like you can define 1 as ONE, etc.
The typedef interpretation is performed by the compiler where as #define statements are processed by the pre-processor.

Taking after is an easiest use of #define:

#import <Foundation/Foundation.h>;

#define TRUE 1

#define FALSE 0

int main( )

{

NSLog( @"Value of TRUE : %d\n", TRUE);

NSLog( @"Value of FALSE : %d\n", FALSE);

return 0;

}

At the point when the above code is gathered and executed, it delivers the accompanying result:

2013-09-12 12:23:37.993 demo[5160] Value of TRUE : 1
2013-09-12 12:23:37.994 demo[5160] Value of FALSE : 0

What is Objective-C Preprocessor

The Objective-C Preprocessor is not piece of the compiler, yet is a different venture in the aggregation process. In oversimplified terms, an Objective-C Preprocessor is simply a content substitution instrument and it trains compiler to do obliged preprocessing before genuine arrangement. We'll allude to the Objective-C Preprocessor as the OCPP.

All preprocessor orders start with a pound image (#). It must be the first nonblank character, and for clarity, a preprocessor mandate ought to start in first segment. Taking after area records down terrifically vital preprocessor mandates:

Directive	Description
#define	Substitutes a preprocessor macro
#include	Inserts a particular header from another file
#undef	Undefines a preprocessor macro
#ifdef	Returns true if this macro is defined
#ifndef	Returns true if this macro is not defined
#if	Tests if a compile time condition is true
#else	The alternative for #if
#elif	#else an #if in one statement
#endif	Ends preprocessor conditional
#error	Prints error message on stderr
#pragma	Issues special commands to the compiler using a standardized method

Preprocessors Examples

Break down the accompanying illustrations to comprehend different orders.

#define MAX_ARRAY_LENGTH 20

This mandate advises the OCPP to supplant examples of MAX_ARRAY_LENGTH with 20. Use #define for constants to build comprehensibility.

#import <Foundation/Foundation.h>
#include "myheader.h"

These mandates advise the OCPP to get foundation.h from Foundation Framework and add the content to the current source record. The following line advises OCPP to get myheader.h from the neighborhood registry and add the substance to the current source document.

#undef  FILE_SIZE
#define FILE_SIZE 42

This advises the OCPP to undefine existing FILE_SIZE and characterize it as 42.

#ifndef MESSAGE
   #define MESSAGE "You wish!"
#endif

This advises the OCPP to characterize MESSAGE just if MESSAGE isn't as of now characterized.

#ifdef DEBUG
   /* Your debugging statements here */
#endif

This advises the OCPP to do the methodology the announcements encased if DEBUG is characterized. This is valuable on the off chance that you pass the -DDEBUG banner to gcc compiler at the time of arrangement. This will characterize DEBUG, so you can turn investigating on and off on the fly amid gathering.

Predefined Macros

ANSI C characterizes various macros. Albeit every one is accessible for your utilization in programming, the predefined macros ought not be specifically altered.

Macro	Description
__DATE__	The current date as a character literal in "MMM DD YYYY" format
__TIME__	The current time as a character literal in "HH:MM:SS" format
__FILE__	This contains the current filename as a string literal.
__LINE__	This contains the current line number as a decimal constant.
__STDC__	Defined as 1 when the compiler complies with the ANSI standard.

We should attempt the accompanying illustration:

#import <Foundation/Foundation.h>;

int main()

{

NSLog(@"File :%s\n", __FILE__ );

NSLog(@"Date :%s\n", __DATE__ );

NSLog(@"Time :%s\n", __TIME__ );

NSLog(@"Line :%d\n", __LINE__ );

NSLog(@"ANSI :%d\n", __STDC__ );

return 0;

}

At the point when the above code in a document main.m is arranged and executed, it delivers the accompanying result:

2013-09-14 04:46:14.859 demo[20683] File :main.m
2013-09-14 04:46:14.859 demo[20683] Date :Sep 14 2013
2013-09-14 04:46:14.859 demo[20683] Time :04:46:14
2013-09-14 04:46:14.859 demo[20683] Line :8
2013-09-14 04:46:14.859 demo[20683] ANSI :1

Preprocessor Operators

The Objective-C preprocessor offers taking after administrators to help you in making macros:

Macro Continuation (\)

A macro generally must be contained on a solitary line. The macro continuation administrator is utilized to proceed with a macro that is too ache for a solitary line. Case in point:

#define  message_for(a, b)  \
    NSLog(@#a " and " #b ": We love you!\n")

Stringize (#)

The stringize or number-sign administrator ('#'), when utilized inside a macro definition, changes over a macro parameter into a string steady. This administrator may be utilized just as a part of a macro that has a predefined contention or parameter list. Case in point:

#import <Foundation/Foundation.h>;

#define message_for(a, b) \

NSLog(@#a " and " #b ": We love you!\n")

int main(void)

{

message_for(Carole, Debra);

return 0;

}

At the point when the above code is incorporated and executed, it creates the accompanying result:

2013-09-14 05:46:14.859 demo[20683] Carole and Debra: We love you!

Token Pasting (##)

The token-sticking administrator (##) inside a macro definition consolidates two contentions. It allows two different tokens in the macro definition to be joined into a solitary token. Case in point:

#import <Foundation/Foundation.h>;

#define tokenpaster(n) NSLog (@"token" #n " = %d", token##n)

int main(void)

{

int token34 = 40;

tokenpaster(34);

return 0;

}

At the point when the above code is accumulated and executed, it creates the accompanying result:

2013-09-14 05:48:14.859 demo[20683] token34 = 40

How it happened, on the grounds that this sample brings about the accompanying genuine yield from the preprocessor:

NSLog (@"token34 = %d", token34);

This case demonstrates the linking of token##n into token34 and here we have utilized both stringize and token-gluing.

The defined() Operator

The preprocessor characterized administrator is utilized as a part of consistent outflows to figure out whether an identifier is characterized utilizing #define. On the off chance that the predetermined identifier is characterized, the quality is genuine (non-zero). In the event that the image is not characterized, the worth is false (zero). The characterized administrator is indicated as takes after

#import <Foundation/Foundation.h>;

#if !defined (MESSAGE)

#define MESSAGE "You wish!"

#endif

int main(void)

{

NSLog(@"Here is the message: %s\n", MESSAGE);

return 0;

}

At the point when the above code is accumulated and executed, it delivers the accompanying result:

2013-09-14 05:48:19.859 demo[20683] Here is the message: You wish!

Parameterized Macros

One of the intense capacities of the OCPP is the capacity to reproduce capacities utilizing parameterized macros. Case in point, we may have some code to square a number as takes after:

int square(int x) {
   return x * x;
}

We can revamp above code utilizing a macro as takes after:

#define square(x) ((x) * (x))

Macros with contentions must be characterized utilizing the #define order before they can be utilized. The contention rundown is encased in brackets and must instantly take after the macro name. Spaces are not permitted between macro name and open bracket. For instance:

#import <Foundation/Foundation.h>;

#define MAX(x,y) ((x) > (y) ? (x) : (y))

int main(void)

{

NSLog(@"Max between 20 and 10 is %d\n", MAX(10, 20));

return 0;

}

At the point when the above code is aggregated and executed, it creates the accompanying result:

2013-09-14 05:52:15.859 demo[20683] Max between 20 and 10 is 20

How use structures in Objective-C

Objective-C clusters permit you to characterize kind of variables that can hold a few information things of the same kind yet structure is another client characterized information sort accessible in Objective-C programming which permits you to consolidate information things of various types.

Structures are utilized to speak to a record, Suppose you need to stay informed concerning your books in a library. You may need to track the accompanying properties about every book:

Title
Author
Subject
Book ID

Characterizing Structure

To characterize a structure, you must utilize the struct proclamation. The struct articulation characterizes another information sort, with more than one part for your project. The organization of the struct explanation is this:

struct [structure tag]
{
   member definition;
   member definition;
   ...
   member definition;
} [one or more structure variables];

The structure tag is discretionary and every part definition is a typical variable definition, for example, int i; or buoy f; or some other substantial variable definition. Toward the end of the structure's definition, before the last semicolon, you can determine one or more structure variables yet it is discretionary. Here is the way you would pronounce the Book structure:

struct Books
{
   NSString *title;
   NSString *author;
   NSString *subject;
   int   book_id;
} book;

Accessing Structure Members

To get to any individual from a structure, we utilize the part get to administrator (.). The part get to administrator is coded as a period between the structure variable name and the structure part that we wish to get to. You would utilize struct essential word to characterize variables of structure sort. Taking after is the sample to clarify utilization of structure:

#import <Foundation/Foundation.h>;

struct Books

{

NSString *title;

NSString *author;

NSString *subject;

int book_id;

};

int main( )

{

struct Books Book1; /* Declare Book1 of type Book */

struct Books Book2; /* Declare Book2 of type Book */

/* book 1 specification */

Book1.title = @"Objective-C Programming";

Book1.author = @"Nuha Ali";

Book1.subject = @"Objective-C Programming Tutorial";

Book1.book_id = 6495407;

/* book 2 specification */

Book2.title = @"Telecom Billing";

Book2.author = @"Zara Ali";

Book2.subject = @"Telecom Billing Tutorial";

Book2.book_id = 6495700;

/* print Book1 info */

NSLog(@"Book 1 title : %@\n", Book1.title);

NSLog(@"Book 1 author : %@\n", Book1.author);

NSLog(@"Book 1 subject : %@\n", Book1.subject);

NSLog(@"Book 1 book_id : %d\n", Book1.book_id);

/* print Book2 info */

NSLog(@"Book 2 title : %@\n", Book2.title);

NSLog(@"Book 2 author : %@\n", Book2.author);

NSLog(@"Book 2 subject : %@\n", Book2.subject);

NSLog(@"Book 2 book_id : %d\n", Book2.book_id);

return 0

}

At the point when the above code is ordered and executed, it creates the accompanying result:

2013-09-14 04:20:07.947 demo[20591] Book 1 title : Objective-C Programming
2013-09-14 04:20:07.947 demo[20591] Book 1 author : Nuha Ali
2013-09-14 04:20:07.947 demo[20591] Book 1 subject : Objective-C Programming Tutorial
2013-09-14 04:20:07.947 demo[20591] Book 1 book_id : 6495407
2013-09-14 04:20:07.947 demo[20591] Book 2 title : Telecom Billing
2013-09-14 04:20:07.947 demo[20591] Book 2 author : Zara Ali
2013-09-14 04:20:07.947 demo[20591] Book 2 subject : Telecom Billing Tutorial
2013-09-14 04:20:07.947 demo[20591] Book 2 book_id : 6495700

Structures as Function Arguments

You can pass a structure as a capacity contention in fundamentally the same path as you pass whatever other variable or pointer. You would get to structure variables in the comparable path as you have gotten to in the above case:

#import <Foundation/Foundation.h>;

struct Books

{

NSString *title;

NSString *author;

NSString *subject;

int book_id;

};

@interface SampleClass:NSObject

/* function declaration */

- (void) printBook:( struct Books) book ;

@end

@implementation SampleClass

- (void) printBook:( struct Books) book

{

NSLog(@"Book title : %@\n", book.title);

NSLog(@"Book author : %@\n", book.author);

NSLog(@"Book subject : %@\n", book.subject);

NSLog(@"Book book_id : %d\n", book.book_id);

}

@end

int main( )

{

struct Books Book1; /* Declare Book1 of type Book */

struct Books Book2; /* Declare Book2 of type Book */

/* book 1 specification */

Book1.title = @"Objective-C Programming";

Book1.author = @"Nuha Ali";

Book1.subject = @"Objective-C Programming Tutorial";

Book1.book_id = 6495407;

/* book 2 specification */

Book2.title = @"Telecom Billing";

Book2.author = @"Zara Ali";

Book2.subject = @"Telecom Billing Tutorial";

Book2.book_id = 6495700;

SampleClass *sampleClass = [[SampleClass alloc]init];

/* print Book1 info */

[sampleClass printBook: Book1];

/* Print Book2 info */

[sampleClass printBook: Book2];

return 0;

}

At the point when the above code is arranged and executed, it creates the accompanying result:

Pointers to Structures

You can characterize pointers to structures in very much alike route as you characterize pointer to whatever other variable as takes after:

struct Books *struct_pointer;

Presently, you can store the location of a structure variable in the above-characterized pointer variable. To discover the location of a structure variable, put the & administrator before the structure's name as takes after:

struct_pointer = &Book1;

To get to the individuals from a structure utilizing a pointer to that structure, you must utilize the -> administrator as takes after:

struct_pointer->title;

Give us a chance to re-compose above sample utilizing structure pointer, trust this will be simple for you to comprehend the idea:

----

Give us a chance to re-compose above sample utilizing structure pointer, trust this will be simple for you to comprehend the idea:

2013-09-14 04:38:13.942 demo[20745] Book title : Objective-C Programming
2013-09-14 04:38:13.942 demo[20745] Book author : Nuha Ali
2013-09-14 04:38:13.942 demo[20745] Book subject : Objective-C Programming Tutorial
2013-09-14 04:38:13.942 demo[20745] Book book_id : 6495407
2013-09-14 04:38:13.942 demo[20745] Book title : Telecom Billing
2013-09-14 04:38:13.942 demo[20745] Book author : Zara Ali
2013-09-14 04:38:13.942 demo[20745] Book subject : Telecom Billing Tutorial
2013-09-14 04:38:13.942 demo[20745] Book book_id : 6495700

Bit Fields

Bit Fields permit the pressing of information in a structure. This is particularly helpful when memory or information stockpiling is at a premium. Average illustrations:

Packing several objects into a machine word. e.g. 1 bit flags can be compacted.
Reading external file formats -- non-standard file formats could be read in. E.g. 9 bit integers.

Objective-C permits us do this in a structure definition by putting :bit length after the variable. Case in point:

struct packed_struct {
  unsigned int f1:1;
  unsigned int f2:1;
  unsigned int f3:1;
  unsigned int f4:1;
  unsigned int type:4;
  unsigned int my_int:9;
} pack;

Here, the packed_struct contains 6 individuals: Four 1 bit banners f1..f3, a 4 bit sort and a 9 bit my_int.

Objective-C consequently packs the above bit fields as minimalistically as would be prudent, given that the most extreme length of the field is not exactly or equivalent to the whole number word length of the PC. In the event that this is not the situation, then a few compilers may permit memory cover for the fields whilst other would store the following field in the following word.

How to use strings in Objective-C

The string in Objective-C programming dialect is spoken to utilizing NSString and its subclass NSMutableString gives a few approaches to making string articles. The most straightforward approach to make a string item is to utilize the Objective-C @"..." build:

NSString *greeting = @"Hello";

A straightforward sample for making and printing a string is demonstrated as follows.

#import <Foundation/Foundation.h>;
int main ()
{
NSString *greeting = @"Hello";
NSLog(@"Greeting message: %@\n", greeting );
return 0;
}

When the above code is compiled and executed, it produces result something as follows:

2013-09-11 01:21:39.922 demo[23926] Greeting message: Hello

Objective-C supports a wide range of methods for manipulate strings:

S.N.	Method & Purpose
1	- (NSString *)capitalizedString; Returns a capitalized representation of the receiver.
2	- (unichar)characterAtIndex:(NSUInteger)index; Returns the character at a given array position.
3	- (double)doubleValue; Returns the floating-point value of the receiver’s text as a double.
4	- (float)floatValue; Returns the floating-point value of the receiver’s text as a float.
5	- (BOOL)hasPrefix:(NSString *)aString; Returns a Boolean value that indicates whether a given string matches the beginning characters of the receiver.
6	- (BOOL)hasSuffix:(NSString *)aString; Returns a Boolean value that indicates whether a given string matches the ending characters of the receiver.
7	- (id)initWithFormat:(NSString *)format ...; Returns an NSString object initialized by using a given format string as a template into which the remaining argument values are substituted.
8	- (NSInteger)integerValue; Returns the NSInteger value of the receiver’s text.
9	- (BOOL)isEqualToString:(NSString *)aString; Returns a Boolean value that indicates whether a given string is equal to the receiver using a literal Unicode-based comparison.
10	- (NSUInteger)length; Returns the number of Unicode characters in the receiver.
11	- (NSString *)lowercaseString; Returns lowercased representation of the receiver.
12	- (NSRange)rangeOfString:(NSString *)aString; Finds and returns the range of the first occurrence of a given string within the receiver.
13	- (NSString )stringByAppendingFormat:(NSString )format ...; Returns a string made by appending to the receiver a string constructed from a given format string and the following arguments.
14	- (NSString )stringByTrimmingCharactersInSet:(NSCharacterSet )set; Returns a new string made by removing from both ends of the receiver characters contained in a given character set.
15	- (NSString *)substringFromIndex:(NSUInteger)anIndex ; Returns a new string containing the characters of the receiver from the one at a given index to the end.

Taking after case makes utilization of few of the aforementioned capacities:

#import <Foundation/Foundation.h>;

int main ()

{

NSString *str1 = @"Hello";

NSString *str2 = @"World";

NSString *str3;

NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];

/* uppercase string */

str3 = [str2 uppercaseString]

NSLog(@"Uppercase String : %@\n", str3 );

/* concatenates str1 and str2 */

str3 = [str1 stringByAppendingFormat:@"World"];

NSLog(@"Concatenated string: %@\n", str3 );

/* total length of str3 after concatenation */

len = [str3 length];

NSLog(@"Length of Str3 : %d\n", len );

/* InitWithFormat */

str3 = [[NSString alloc] initWithFormat:@"%@ %@",str1,str2];

NSLog(@"Using initWithFormat: %@\n", str3 );

[pool drain];

return 0;

}

When the above code is compiled and executed, it produces result something as follows:

2013-09-11 01:15:45.069 demo[30378] Uppercase String :  WORLD
2013-09-11 01:15:45.070 demo[30378] Concatenated string:   HelloWorld
2013-09-11 01:15:45.070 demo[30378] Length of Str3 :  10
2013-09-11 01:15:45.070 demo[30378] Using initWithFormat:   Hello World

You can find a complete list of Objective-C NSString related methods in NSString Class Reference.

How Use Pointers in Objective-C

Pointers in Objective-C are simple and enjoyable to learn. Some Objective-C programming undertakings are performed all the more effectively with pointers, and different errands, for example, dynamic memory designation, can't be performed without utilizing pointers. So it gets to be important to learn pointers to turn into a flawless Objective-C developer. How about we begin learning them in straightforward and simple steps.

As you know, each variable is a memory area and each memory area has its address characterized which can be gotten to utilizing ampersand (&) administrator, which indicates a location in memory. Consider the accompanying sample, which will print the location of the variables characterized:

#import <Foundation/Foundation.h>;

int main ()
{
int var1;
char var2[10];

NSLog(@"Address of var1 variable: %x\n", &var1 );
NSLog(@"Address of var2 variable: %x\n", &var2 );

return 0;
}

At the point when the above code is accumulated and executed, it delivers the outcome something as takes after:

2013-09-13 03:18:45.727 demo[17552] Address of var1 variable: 1c0843fc
2013-09-13 03:18:45.728 demo[17552] Address of var2 variable: 1c0843f0

Thus, you comprehended what is memory location and how to get to it, so base of the idea is over. Presently give us a chance to see what is a pointer.

What Are Pointers?

A pointer is a variable whose quality is the location of another variable, i.e., direct address of the memory area. Like any variable or steady, you must announce a pointer before you can utilize it to store any variable location. The general manifestation of a pointer variable announcement is:

type *var-name;

Here, sort is the pointer's base sort; it must be a legitimate Objective-C information sort and var-name is the name of the pointer variable. The reference mark * you used to pronounce a pointer is the same indicator that you use for duplication. Be that as it may, in this announcement the reference bullet is being utilized to assign a variable as a pointer. Taking after are the substantial pointer announcement:

int    *ip;    /* pointer to an integer */
double *dp;    /* pointer to a double */
float  *fp;    /* pointer to a float */
char   *ch     /* pointer to a character */

The real information kind of the estimation of all pointers, whether whole number, buoy, character, or something else, is the same, a long hexadecimal number that speaks to a memory address. The main distinction between pointers of diverse information sorts is the information sort of the variable or steady that the pointer focuses to.

How to use Pointers?

There are couple of imperative operations, which we will do with the assistance of pointers much of the time. (a) we characterize a pointer variable, (b) allot the location of a variable to a pointer, and (c) at last get to the quality at the location accessible in the pointer variable. This is carried out by utilizing unary administrator * that profits the estimation of the variable found at the location indicated by its operand. Taking after illustration makes utilization of these operations:

#import <Foundation/Foundation.h>;

int main ()

{

int var = 20; /* actual variable declaration */

int *ip; /* pointer variable declaration */

ip = &var; /* store address of var in pointer variable*/

NSLog(@"Address of var variable: %x\n", &var );

NSLog(@"Address stored in ip variable: %x\n", ip );

NSLog(@"Value of *ip variable: %d\n", *ip );

return 0;

}

At the point when the above code is accumulated and executed, it creates the outcome something as takes after:

2013-09-13 03:20:21.873 demo[24179] Address of var variable: 337ed41c
2013-09-13 03:20:21.873 demo[24179] Address stored in ip variable: 337ed41c
2013-09-13 03:20:21.874 demo[24179] Value of *ip variable: 20

NULL Pointers in Objective-C

It is dependably a decent practice to allot a NULL quality to a pointer variable in the event that you don't have accurate location to be alloted. This is carried out at the time of variable presentation. A pointer that is alloted NULL is known as an invalid pointer.

The NULL pointer is a consistent with an estimation of zero characterized in a few standard libraries. Consider the accompanying project:

#import <Foundation/Foundation.h>;

int main ()

{

int *ptr = NULL;

NSLog(@"The value of ptr is : %x\n", ptr );

return 0;

}

At the point when the above code is aggregated and executed, it creates the accompanying result:

2013-09-13 03:21:19.447 demo[28027] The value of ptr is : 0

On the vast majority of the working frameworks, projects are not allowed to get to memory at address 0 in light of the fact that that memory is saved by the working framework. Then again, the memory address 0 has exceptional hugeness; it flags that the pointer is not expected to indicate an open memory area. Be that as it may by tradition, if a pointer contains the invalid (zero) quality, it is expected to indicate nothing.

To check for an invalid pointer, you can utilize an if proclamation as takes after:

if(ptr)     /* succeeds if p is not null */
if(!ptr)    /* succeeds if p is null */

Objective-C Pointers in Detail:

Pointers have numerous yet simple ideas and they are essential to Objective-C programming. There are taking after couple of critical pointer ideas, which ought to be clear to an Objective-C software engineer:

Concept	Description
Objective-C - Pointer arithmetic	There are four arithmetic operators that can be used on pointers: ++, --, +, -
Objective-C - Array of pointers	You can define arrays to hold a number of pointers.
Objective-C - Pointer to pointer	Objective-C allows you to have pointer on a pointer and so on.
Passing pointers to functions in Objective-C	Passing an argument by reference or by address both enable the passed argument to be changed in the calling function by the called function.
Return pointer from functions in Objective-C	Objective-C allows a function to return a pointer to local variable, static variable and dynamically allocated memory as well.

CodeWorld55

Objective-C Typedef

typedef vs #define

Objective-C Preprocessors

Preprocessors Examples

Predefined Macros

Preprocessor Operators

Macro Continuation (\)

Stringize (#)

Token Pasting (##)

The defined() Operator

Parameterized Macros

Objective-C Structures

Characterizing Structure

Accessing Structure Members

Structures as Function Arguments

Pointers to Structures

Bit Fields

Objective-C Strings

Objective-C Pointers

What Are Pointers?

NULL Pointers in Objective-C

Objective-C Pointers in Detail:

My Instagram

Topics