For clarification: A C string is simply a series of characters (a one-dimensional character array) that is null-terminated, whereas an NSString object is a complete object with class methods, instance methods, etc.

The first code block below shows how to create an NSString object and convert it to a C string. The second example shows a C string converted to an NSString object.

// NSString object to C
NSString *str = @"String object to a C string";
const char *ptr = [str cStringUsingEncoding:NSUTF8StringEncoding];
printf("%s\n", ptr);
 
// Another approach with the same result
const char *ptr2 = [str UTF8String];
printf("%s\n", ptr2);
 
// C string to NSString object
ptr = "C string to string object";
str = [NSString stringWithCString:ptr encoding:NSUTF8StringEncoding];
NSLog(@"%@", str);

#error

When the preprocessor runs into the #error directive, it will write an error to the console and generate a compile time error. You can also include a text string which is displayed as an error message.

For example, when writing a previous blog post about using JSON and the Flickr API , I needed a way to flag developers who downloaded the source code to insert their own Flickr ID into the application code. I did this by using the following code which generated a compile time error and displayed a message to the console informing the user what was up.

#error : Change this value to your Flickr key
NSString *const FlickrAPIKey = @"your-key-here";

Another time this can be helpful is when you need to verify that some particular value has been defined for the application. As a simple example, let’s say the our application needs to be flagged as either a paid or free app – we could write something similar to the following as a verification this step has been completed:

// Validate the application type has been set
#ifdef PAID_APP
  // Do something
#elif FREE_APP
  // Do something else
#else
  #error : No App type defined
#endif`

When I write the error message notice that I insert a “:” character as it helps to break apart the error message. Also worth mentioning is that the preprocessor will work through all the source code files before the compiler stops, which is nice in that you can have more than one #error message. The figure below shows error messages from two separate source files:

As a final example, I’ve also used this as a personal marker in a block of code so that I could recall where I was and what I was working on when setting something aside. This is nice if you need to walk away from a project for some time and want an unavoidable reminder of where you left off.

#error : Check this code first

#warning

The directive #warning is similar however the preprocessor doesn’t stop when it finds this directive, it simply displays the message to the console and keeps on with the task at hand. One common use of #warning is to display information regarding deprecated code:

#warning : This method is deprecated, use someNewMethod instead

Note:
You can optionally surround the #error and #warning messages in quotes.

/*
  // Detect touch anywhere
  UITouch *touch = [touches anyObject];
 
  // Where is the point touched
  CGPoint point = [touch locationInView:self.view]; 
  NSLog(@"pointx: %f pointy:%f", point.x, point.y);
 
  // Was a tab touched, if so, which one...
  if (CGRectContainsPoint(CGRectMake(1, 440, 106, 40), point))
	  NSLog(@"tab 1 touched");
  else if (...)
    ... more code here
  else if (...)
    ... more code here
 
*/

This approach works well, with one exception, nested comments in the form of /* … */ will generate a compiler error, see lines 9 – 10 below:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

/*
  // Detect touch anywhere
  UITouch *touch = [touches anyObject];
 
  // Where is the point touched
  CGPoint point = [touch locationInView:self.view]; 
  NSLog(@"pointx: %f pointy:%f", point.x, point.y);
 
  /* If you have an embedded comment in this style,
       you will get a compiler error */
  if (CGRectContainsPoint(CGRectMake(1, 440, 106, 40), point))
	  NSLog(@"tab 1 touched");
  else if (...)
    ... more code here
  else if (...)
    ... more code here
 
*/

To get around the problem with embedded comments, you can try this approach:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

#if 0
  // Detect touch anywhere
  UITouch *touch = [touches anyObject];
 
  // Where is the point touched
  CGPoint point = [touch locationInView:self.view]; 
  NSLog(@"pointx: %f pointy:%f", point.x, point.y);
 
  /* If you have an embedded comment in this style,
       you will get a compiler error */
  if (CGRectContainsPoint(CGRectMake(1, 440, 106, 40), point))
	  NSLog(@"tab 1 touched");
  else if (...)
    ... more code here
  else if (...)
    ... more code here
 
#endif

Another option that is a little more descriptive:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

#ifdef VISIBLE
  // Detect touch anywhere
  UITouch *touch = [touches anyObject];
 
  // Where is the point touched
  CGPoint point = [touch locationInView:self.view]; 
  NSLog(@"pointx: %f pointy:%f", point.x, point.y);
 
  /* If you have an embedded comment in this style,
       you will get a compiler error */
  if (CGRectContainsPoint(CGRectMake(1, 440, 106, 40), point))
	  NSLog(@"tab 1 touched");
  else if (...)
    ... more code here
  else if (...)
    ... more code here
 
#endif

This approach provides a means to quickly comment in/out any number of code blocks by simply modifying a compiler directive as shown here:

// Code above will be compiled
// Change to INVISIBLE and code will ~not~ be compiled
#define VISIBLE

The conditional looks as follow:

condition-test ? first-expression : second-expression

If the condition-test is nonzero, the first-expression is evaluated, otherwise the second-expression is evaluated.

// Traditional approach
if (x > 0)
  str = @"positive";
else
  str = @"negative";
 
// Conditional operator
str = x > 0 ? @"positive" : @"negative";

Nesting Conditional Operators

Extending the example above, we can update the code for the case where x is neither positive or negative (x is zero), using nested conditionals:

// Traditional approach
if (x > 0)
  str = @"positive";
else if (x < 0)
  str = @"negative";
else
  str = @"zero";
 
// Conditional operator
str = x > 0 ? @"positive" : x < 0 ? @"negative" : @"zero";

As shown above, based on the association of parameters, no parenthesis are necessary, however, I find this much easier to read:

str = x > 0 ? @"positive" : (x < 0 ? @"negative" : @"zero");

Good Use Case

I find the conditional operator useful when creating messages in which part of the message may be plural or singular depending on the value of a variable.

It’s not much more work to make messages appear as expected, for example, how often have you seen a message from an application that looks similar to this “1 file(s) downloaded” where ideally the message would read “1 file downloaded” – not a big deal, however, it’s a trivial amount of code to get this right:

int x = 1;
NSString *str = 
  [NSString stringWithFormat:@"%d file%s downloaded", x, (x > 1 ? "s" : "")];

Sometimes it’s the little things that will setup you apart in a crowd of developers.

arc4random() tends to be preferred as it does not require seeding, the function automatically initializes itself.

// Get random value between 0 and 99
int x = arc4random() % 100;
 
// Get random number between 500 and 1000
int y =  (arc4random() % 501) + 500);

In a recent application I wrote a method with one parameter, an integer, that is expected to be 1 or 0. In creating a demo of the application I wanted to pass in alternating values of 1 and 0 as part of a test for a specific use case. Instead of using an if statement in the calling method to decide when to send a 1 or 0, I wrote something similar to the code below:

- (void)someMethod
{
  static int x = 0;
 
  // Toggles 1 to 0 and 0 to 1 using xor
  x ^= 1;
 
  // Call the method that expects a 1 or 0
  [methodCallHere toggle:x];
}

More often than not, exclusive-OR (^), AND (&) and inclusive-OR (|) are consider a bit-level operations (see this post on bitfields). However, there are times when these operators work equally well with integer values.

The code that follows is pure C. Given that Objective-C is a superset of C, don’t forget that you can leverage all that C has to offer, beyond working with objects.

1
2
3
4
5
6

struct
{
  unsigned preLoaded: 1;
  unsigned saveState: 1;
  unsigned saveLoginName: 1;
} statusFlags;

I’ve defines three bitfields, all which will be saved within an unsigned integer. Accessing the bits is as easy as this:

1
2
3
4
5
6
7

// Setting bits
statusFlags.preLoaded = 1;
statusFlags.saveState = statusFlags.saveLoginName = 0;
 
// Get bits
if (statusFlags.saveLoginName == 0)
  ... do something here...

Using the sizeof() function, let’s compare the size of an integer to the size of the structure we created:

1
2
3
4
5
6
7
8
9
10
11
12

// Setting bits
statusFlags.preLoaded = 1;
statusFlags.saveState = statusFlags.saveLoginName = 0;
 
// Get bits
if (statusFlags.saveLoginName == 0)
  NSLog(@"saveLoginName bit is on.");
else
  NSLog(@"saveLoginName bit is off.");  
 
NSLog(@"Sizeof int: %d", sizeof(int)); 
NSLog(@"Sizeof statusFlags: %d", sizeof(statusFlags));

The output looks as follows, which verifies that the bitfields are maintained within a single unsigned integer.

What’s interesting is that we now know that an integer is 4 bytes, this would imply that we can store up to 32 separate flags within our structure. To verify this the case, let’s create a new structure that looks as follows:

1
2
3
4
5
6
7
8

struct
{
  unsigned preLoaded: 1;
  unsigned saveState: 1;
  unsigned saveLoginName: 1;
  unsigned buffer: 28;
  unsigned savePassword: 1;
} statusFlagsExtended;

In this structure, ‘buffer’ is nothing more than a means for me to soak up 28 bits such that I can add one more bit on the end. Let’s take a look at the sizeof this structure with the code below:

1
2
3
4
5
6
7
8
9
10
11
12
13

// Setting bits
statusFlags.preLoaded = 1;
statusFlags.saveState = statusFlags.saveLoginName = 0;
 
// Get bits
if (statusFlags.saveLoginName == 0)
  NSLog(@"saveLoginName bit is on.");
else
  NSLog(@"saveLoginName bit is off.");  
 
NSLog(@"Sizeof int: %d", sizeof(int)); 
NSLog(@"Sizeof statusFlags: %d", sizeof(statusFlags));
NSLog(@"Sizeof statusFlagsExtended: %d", sizeof(statusFlagsExtended));

As expected, the structure ‘statusFlagsExtended’ is also stored as an integer.

Even thought the bulk of developing iPhone application is all about Objective-C, don’t forget to lean on C as needed to get the job done.

CGRectMake and NSStringFromCGRect

With CGRectMake we can create a new CGRect structure. The rectangles below have differing starting points, however, each have a width and height of 100. The function NSStringFromCGRect returns a string object that defines the rectangle passed in as a parameter:

1
2
3
4
5

CGRect rect1 = CGRectMake(100, 100, 100, 100);
CGRect rect2 = CGRectMake(190, 190, 100, 100);
 
NSLog(@"rect1: %@", NSStringFromCGRect(rect1));
NSLog(@"rect2: %@", NSStringFromCGRect(rect2));

Note : The output of all examples are shown in the image at the bottom of this post.

CGRectIntersect

To determine if two rectangles intersect, you can write code as follows:

1
2
3
4
5
6
7
8
9
10

CGRect rect3 = CGRectMake(100, 100, 100, 100);
CGRect rect4 = CGRectMake(190, 190, 100, 100);
 
if (CGRectIntersectsRect(rect3, rect4) == 1)
  NSLog(@"The rectangles intersect");
else
  NSLog(@"The rectangles do not intersect");    
 
NSLog(@"rect3: %@", NSStringFromCGRect(rect3));
NSLog(@"rect4: %@", NSStringFromCGRect(rect4));

CGRectInset

If you need to create a rectangle that is either larger or smaller than an existing rectangle, centered on the same point, try CGRectInset:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

CGRect rect5 = CGRectMake(100, 100, 100, 100);
// Use positive values for a smaller rectangle
CGRect rect6 = CGRectInset(rect, 25, 25);
 
NSLog(@"%rect5: %@", NSStringFromCGRect(rect5));
NSLog(@"%rect6: %@", NSStringFromCGRect(rect6));
 
...
 
CGRect rect7 = CGRectMake(100, 100, 100, 100);
// Use negative values for a larger rectangle
CGRect rect8 = CGRectInset(rect, -25, -25);
 
NSLog(@"rect7: %@", NSStringFromCGRect(rect7));
NSLog(@"rect8: %@", NSStringFromCGRect(rect8));

CGRectFromString

A little more uncommon, is creating rectangles from a string, however, if the need arises:

1
2
3

NSString *str = @"{{0,0},{50,50}}";
CGRect rect9 = CGRectFromString(str);
NSLog(@"rect9: %@", NSStringFromCGRect(rect9));

Functions for CGSize and CGPoint

As you would expect, there are similar functions to those above for working with CGSize and CGPoint:

• CGSizeMake
• CGSizeEqualToSize
• CGPointMake
• CGPointEqualToPoint

The output for the above code examples follows:

1
2
3
4
5

struct CGRect {
   CGPoint origin;
   CGSize size;
};
typedef struct CGRect CGRect;

Going a little further, we can find that CGPoint and CGSize are defined as follows:

1
2
3
4
5
6
7
8
9
10
11

struct CGPoint {
   CGFloat x;
   CGFloat y;
};
typedef struct CGPoint CGPoint;
 
struct CGSize {
   CGFloat width;
   CGFloat height;
};
typedef struct CGSize CGSize;

And to wrap up, CGFloat looks as follows:

1
2

typedef float CGFloat;    // 32-bit
typedef double CGFloat; // 64-bit

Here’s what we can summarize, a CGRect defines a rectangle as an origin (x and y location) and its size (width and height), with all values represented as floats. Access to the member variables of these structures (and all structure members for that matter) is through dot syntax as shown in the example below:

1
2
3
4
5
6
7

  CGRect bounds = [[UIScreen mainScreen] bounds];
  CGRect appframe= [[UIScreen mainScreen] applicationFrame];
 
  NSLog(@"mainScreen bounds: %.0f, %.0f, %3.0f, %3.0f", 
     bounds.origin.x, bounds.origin.y, bounds.size.width, bounds.size.height);
  NSLog(@"mainScreen applicationFrame: %.0f, %.0f, %3.0f, %3.0f", 
     appframe.origin.x, appframe.origin.y, appframe.size.width, appframe.size.height);

In an upcoming post I’ll look into some of the functions that are available to us when working with the above structures.

Creating a Structure

1
2
3
4

struct point{
  int x;
  int y;
};

With this definition in place, we can create new instances of a point as shown below. Also, notice how structure members are accessed using dot syntax.

1
2
3
4
5
6
7
8
9

// Allocate, then initialize
struct point topLeft;
topLeft.x = 15, topLeft.y = 20;
 
// Allocate and initialize in one step
struct point lowerRight = {100, 200};
 
NSLog(@"x: %d y: %d", topLeft.x, topLeft.y);
NSLog(@"x: %d y: %d", lowerRight.x, lowerRight.y);

Typedef

We can add a typedef (type definition) to create a more convenient data type name. Look at the code that follows:

1
2
3
4
5

struct point{
  int x;
  int y;
};
typedef struct point POINT;

Now, we can create new points as shown here:

1
2
3
4
5
6
7
8
9

// Allocate, then initialize
POINT topLeft;
topLeft.x = 15, topLeft.y = 20;
 
// Allocate and initialize in one step
POINT lowerRight = {100, 200};
 
NSLog(@"x: %d y: %d", topLeft.x, topLeft.y);
NSLog(@"x: %d y: %d", lowerRight.x, lowerRight.y);

It’s important to note, a typedef is nothing more than a name for an existing type, there is no new data type created.

Nested Structures

We can also nest structures, below I create a definition for a rectangle, by using two points:

1
2
3
4
5
6
7
8
9
10
11

struct point{
  int x;
  int y;
};
typedef struct point POINT;
 
struct rectangle {
  POINT topLeft;
  POINT lowerRight;
};
typedef struct rectangle RECTANGLE;

Here’s how one might use the rectangle structure.

1
2
3

RECTANGLE box = {100, 100, 200, 300};
NSLog(@"x: %d y: %d", box.topLeft.x, box.topLeft.y);
NSLog(@"x: %d y: %d", box.lowerRight.x, box.lowerRight.y);

That should cover what we need to look a little further into the structures CGRect, CGPoint and CGSize in another post.