| /* |
| Simple CFString example program. |
| Author: Ali Ozer |
| 4/2/99 |
| |
| Note: Compile as "gcc -framework CoreFoundation -o stringtest StringExample.c" |
| |
| Copyright (c) 1999-2004, Apple Computer, Inc., all rights reserved. |
| */ |
| /* |
| IMPORTANT: This Apple software is supplied to you by Apple Computer, Inc. ("Apple") in |
| consideration of your agreement to the following terms, and your use, installation, |
| modification or redistribution of this Apple software constitutes acceptance of these |
| terms. If you do not agree with these terms, please do not use, install, modify or |
| redistribute this Apple software. |
| |
| In consideration of your agreement to abide by the following terms, and subject to these |
| terms, Apple grants you a personal, non-exclusive license, under Appleās copyrights in |
| this original Apple software (the "Apple Software"), to use, reproduce, modify and |
| redistribute the Apple Software, with or without modifications, in source and/or binary |
| forms; provided that if you redistribute the Apple Software in its entirety and without |
| modifications, you must retain this notice and the following text and disclaimers in all |
| such redistributions of the Apple Software. Neither the name, trademarks, service marks |
| or logos of Apple Computer, Inc. may be used to endorse or promote products derived from |
| the Apple Software without specific prior written permission from Apple. Except as expressly |
| stated in this notice, no other rights or licenses, express or implied, are granted by Apple |
| herein, including but not limited to any patent rights that may be infringed by your |
| derivative works or by other works in which the Apple Software may be incorporated. |
| |
| The Apple Software is provided by Apple on an "AS IS" basis. APPLE MAKES NO WARRANTIES, |
| EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION THE IMPLIED WARRANTIES OF NON-INFRINGEMENT, |
| MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, REGARDING THE APPLE SOFTWARE OR ITS |
| USE AND OPERATION ALONE OR IN COMBINATION WITH YOUR PRODUCTS. |
| |
| IN NO EVENT SHALL APPLE BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL OR CONSEQUENTIAL |
| DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS |
| OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ARISING IN ANY WAY OUT OF THE USE, |
| REPRODUCTION, MODIFICATION AND/OR DISTRIBUTION OF THE APPLE SOFTWARE, HOWEVER CAUSED AND |
| WHETHER UNDER THEORY OF CONTRACT, TORT (INCLUDING NEGLIGENCE), STRICT LIABILITY OR |
| OTHERWISE, EVEN IF APPLE HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| #include <stdio.h> |
| #include <stdlib.h> |
| |
| #include <CoreFoundation/CoreFoundation.h> |
| |
| |
| // This function will print the provided arguments (printf style varargs) out to the console. |
| // Note that the CFString formatting function accepts "%@" as a way to display CF types. |
| // For types other than CFString and CFNumber, the result of %@ is mostly for debugging |
| // and can differ between releases and different platforms. |
| void show(CFStringRef formatString, ...) { |
| CFStringRef resultString; |
| CFDataRef data; |
| va_list argList; |
| |
| va_start(argList, formatString); |
| resultString = CFStringCreateWithFormatAndArguments(NULL, NULL, formatString, argList); |
| va_end(argList); |
| |
| data = CFStringCreateExternalRepresentation(NULL, resultString, CFStringGetSystemEncoding(), '?'); |
| |
| if (data != NULL) { |
| printf ("%.*s\n\n", (int)CFDataGetLength(data), CFDataGetBytePtr(data)); |
| CFRelease(data); |
| } |
| |
| CFRelease(resultString); |
| } |
| |
| |
| void simpleStringExample(void) { |
| |
| CFStringRef str; |
| CFDataRef data; |
| char *bytes; |
| |
| show(CFSTR("------------------Simple Strings---------------")); |
| |
| // Create a simple immutable string from a Pascal string and convert it to Unicode |
| #if defined(__APPLE__) |
| str = CFStringCreateWithPascalString(NULL, "\pFoo Bar", kCFStringEncodingASCII); |
| #else |
| str = CFStringCreateWithCString(NULL, "Hello World", kCFStringEncodingASCII); |
| #endif |
| |
| // Create the Unicode representation of the string |
| // "0", lossByte, indicates that if there's a conversion error, fail (and return NULL) |
| data = CFStringCreateExternalRepresentation(NULL, str, kCFStringEncodingUnicode, 0); |
| |
| show(CFSTR("String : %@"), str); |
| show(CFSTR("Unicode data : %@"), data); |
| |
| CFRelease(str); |
| |
| // Create a string from the Unicode data... |
| str = CFStringCreateFromExternalRepresentation(NULL, data, kCFStringEncodingUnicode); |
| |
| show(CFSTR("String Out : %@"), str); |
| |
| CFRelease(str); |
| |
| // Create a string for which you already have some allocated contents which you want to |
| // pass ownership of to the CFString. The last argument, "NULL," indicates that the default allocator |
| // should be used to free the contents when the CFString is freed (or you can pass in CFAllocatorGetDefault()). |
| |
| bytes = (char*)CFAllocatorAllocate(CFAllocatorGetDefault(), 6, 0); |
| strcpy(bytes, "Hello"); |
| |
| str = CFStringCreateWithCStringNoCopy(NULL, bytes, kCFStringEncodingASCII, NULL); |
| CFRelease(str); |
| |
| #if defined(__APPLE__) |
| // Now create a string with a Pascal string which is not copied, and not freed when the string is |
| // This is an advanced usage; obviously you need to guarantee that the string bytes do not go away |
| // before the CFString does. |
| str = CFStringCreateWithPascalStringNoCopy(NULL, "\pFoo Bar", kCFStringEncodingASCII, kCFAllocatorNull); |
| CFRelease(str); |
| #endif |
| } |
| |
| |
| |
| void stringGettingContentsAsCStringExample(void) { |
| |
| CFStringRef str; |
| CFDataRef data; |
| CFRange rangeToProcess; |
| const char *bytes; |
| |
| show(CFSTR("------------------C String Manipulations---------------")); |
| |
| // Create some test CFString |
| // Note that in general the string might contain Unicode characters which cannot |
| // be converted to a 8-bit character encoding |
| str = CFStringCreateWithCString(NULL, "Hello World", kCFStringEncodingASCII); |
| |
| show(CFSTR("Original String : %@"), str); |
| |
| // First, the fast but unpredictable way to get at the C String contents... |
| // This is O(1), meaning it takes constant time. |
| // This might return NULL! |
| bytes = CFStringGetCStringPtr(str, kCFStringEncodingASCII); |
| |
| // If that fails, you can try to get the contents by copying it out |
| if (bytes == NULL) { |
| char localBuffer[10]; |
| Boolean success; |
| |
| // This might also fail, either if you provide a buffer that is too small, |
| // or the string cannot be converted into the specified encoding |
| success = CFStringGetCString(str, localBuffer, 10, kCFStringEncodingASCII); |
| } |
| else |
| show(CFSTR("From CStringPtr : %@"), bytes); |
| |
| // A pretty simple solution is to use a CFData; this frees you from guessing at the buffer size |
| // But it does allocate a CFData... |
| data = CFStringCreateExternalRepresentation(NULL, str, kCFStringEncodingASCII, 0); |
| if (data) { |
| show(CFSTR("External Rep: %@"), data); |
| bytes = (const char *)CFDataGetBytePtr(data); |
| } |
| |
| // More complicated but efficient solution is to use a fixed size buffer, and put a loop in |
| rangeToProcess = CFRangeMake(0, CFStringGetLength(str)); |
| |
| while (rangeToProcess.length > 0) { |
| UInt8 localBuffer[100]; |
| CFIndex usedBufferLength; |
| CFIndex numChars = CFStringGetBytes(str, rangeToProcess, kCFStringEncodingASCII, 0, FALSE, (UInt8 *)localBuffer, 100, &usedBufferLength); |
| |
| if (numChars == 0) break; // Means we failed to convert anything... |
| |
| // Otherwise we converted some stuff; process localBuffer containing usedBufferLength bytes |
| // Note that the bytes in localBuffer are not NULL terminated |
| |
| // Update the remaining range to continue looping |
| rangeToProcess.location += numChars; |
| rangeToProcess.length -= numChars; |
| } |
| } |
| |
| |
| void stringGettingAtCharactersExample(void) { |
| |
| CFStringRef str; |
| const UniChar *chars; |
| |
| show(CFSTR("------------------Character Manipulations---------------")); |
| |
| // Create some test CFString |
| str = CFStringCreateWithCString(NULL, "Hello World", kCFStringEncodingASCII); |
| |
| show(CFSTR("Original String : %@"), str); |
| |
| // The fastest way to get the contents; this might return NULL though |
| // depending on the system, the release, etc, so don't depend on it |
| // (unless you used CFStringCreateMutableWithExternalCharactersNoCopy()) |
| chars = CFStringGetCharactersPtr(str); |
| |
| // If that fails, you can try copying the UniChars out |
| // either into some stack buffer or some allocated piece of memory... |
| // Using the former is fine, but you need to know the size; the latter |
| // always works but requires allocating some memory; not too efficient. |
| if (chars == NULL) { |
| CFIndex length = CFStringGetLength(str); |
| UniChar *buffer = (UniChar*)malloc(length * sizeof(UniChar)); |
| CFStringGetCharacters(str, CFRangeMake(0, length), buffer); |
| // Process the chars... |
| free(buffer); |
| } |
| else |
| show(CFSTR("Characters : %@"), str); |
| |
| // You can use CFStringGetCharacterAtIndex() to get at the characters one at a time, |
| // but doing a lot of characters this way might get slow... |
| // An option is to use "inline buffer" functionality which mixes the convenience of |
| // one-at-a-time char access with efficiency of bulk access |
| { |
| CFStringInlineBuffer inlineBuffer; |
| CFIndex length = CFStringGetLength(str); |
| CFIndex cnt; |
| |
| CFStringInitInlineBuffer(str, &inlineBuffer, CFRangeMake(0, length)); |
| |
| for (cnt = 0; cnt < length; cnt++) { |
| UniChar ch = CFStringGetCharacterFromInlineBuffer(&inlineBuffer, cnt); |
| // Process character... |
| (void)ch; // Dummy processing to prevent compiler warning... |
| } |
| } |
| |
| } |
| |
| |
| void stringWithExternalContentsExample(void) { |
| #define BufferSize 1000 |
| CFMutableStringRef mutStr; |
| UniChar *myBuffer; |
| |
| show(CFSTR("------------------External Contents Examples---------------")); |
| |
| // Allocate a contents store that is empty (but has space for BufferSize chars)... |
| myBuffer = (UniChar*)malloc(BufferSize * sizeof(UniChar)); |
| |
| // Now create a mutable CFString which uses this buffer |
| // The 0 and BufferSize indicate the length and capacity (in UniChars) |
| // The kCFAllocatorNull indicates how the CFString should reallocate or free this buffer (in this case, do nothing) |
| |
| mutStr = CFStringCreateMutableWithExternalCharactersNoCopy(NULL, myBuffer, 0, BufferSize, kCFAllocatorNull); |
| CFStringAppend(mutStr, CFSTR("Appended string... ")); |
| CFStringAppend(mutStr, CFSTR("More stuff... ")); |
| #if defined(__APPLE__) |
| CFStringAppendPascalString(mutStr, "\pA pascal string. ", kCFStringEncodingASCII); |
| #else |
| CFStringAppendCString(mutStr, "A C string. ", kCFStringEncodingASCII); |
| #endif |
| CFStringAppendFormat(mutStr, NULL, CFSTR("%d %4.2f %@..."), 42, -3.14, CFSTR("Hello")); |
| |
| show(CFSTR("String: %@"), mutStr); |
| |
| CFRelease(mutStr); |
| free(myBuffer); |
| |
| // Now create a similar string, but give CFString the ability to reallocate or free the buffer |
| // The last "NULL" argument specifies that the default allocator should be used |
| // Here we provide an initial buffer of 32 characters, but if it grows beyond this, it's OK |
| // (unlike the previous example, where if the string grew beyond 1000, it's an error) |
| |
| myBuffer = (UniChar*)CFAllocatorAllocate(CFAllocatorGetDefault(), 32 * sizeof(UniChar), 0); |
| mutStr = CFStringCreateMutableWithExternalCharactersNoCopy(NULL, myBuffer, 0, 32, NULL); |
| |
| CFStringAppend(mutStr, CFSTR("Appended string... ")); |
| CFStringAppend(mutStr, CFSTR("Appended string... ")); |
| CFStringAppend(mutStr, CFSTR("Appended string... ")); |
| CFStringAppend(mutStr, CFSTR("Appended string... ")); |
| CFStringAppend(mutStr, CFSTR("Appended string... ")); |
| |
| show(CFSTR("String: %@"), mutStr); |
| |
| CFRelease(mutStr); |
| // Here we don't free the buffer, as CFString does that |
| } |
| |
| void stringManipulation(void) { |
| |
| CFMutableStringRef strChange; |
| CFStringRef strOuter, find, replace, find2, replace2, find3, replace3, bigger, smaller, result; |
| CFComparisonResult comp; |
| CFLocaleRef curLocale; |
| |
| show(CFSTR("------------------String Manipulations---------------")); |
| |
| // Create a simple immutable string from a Pascal string and convert it to Unicode |
| strOuter = CFStringCreateWithCString(NULL, "Hello Cruel World", kCFStringEncodingASCII); |
| strChange = CFStringCreateMutableCopy(NULL, CFStringGetLength(strOuter), strOuter); |
| find = CFStringCreateWithCString(NULL, "Cruel", kCFStringEncodingASCII); |
| replace = CFStringCreateWithCString(NULL, "Cool", kCFStringEncodingASCII); |
| find2 = CFStringCreateWithCString(NULL, "Keep", kCFStringEncodingASCII); |
| replace2 = CFStringCreateWithCString(NULL, "Be", kCFStringEncodingASCII); |
| find3 = CFStringCreateWithCString(NULL, "Change.", kCFStringEncodingASCII); |
| replace3 = CFStringCreateWithCString(NULL, "Ball.", kCFStringEncodingASCII); |
| |
| bigger = CFStringCreateWithCString(NULL, "version 2.5", kCFStringEncodingASCII); |
| smaller = CFStringCreateWithCString(NULL, "version 2.0", kCFStringEncodingASCII); |
| |
| show(CFSTR("String Outer : %@"), strOuter); |
| show(CFSTR("String Find : %@"), find); |
| show(CFSTR("String Replace : %@"), replace); |
| |
| CFStringFindAndReplace(strChange, find, replace, CFRangeMake(0, CFStringGetLength(strChange)), 0); |
| |
| show(CFSTR("Replaced : %@"), strChange); |
| |
| CFStringAppendCString(strChange, "! Keep the change.", kCFStringEncodingASCII); |
| |
| show(CFSTR("Appended : %@"), strChange); |
| |
| curLocale = CFLocaleCopyCurrent (); |
| |
| CFStringUppercase(strChange, curLocale); |
| |
| show(CFSTR("Upper Cased : %@"), strChange); |
| |
| CFStringLowercase(strChange, curLocale); |
| |
| show(CFSTR("Lower Cased : %@"), strChange); |
| |
| CFStringCapitalize(strChange, curLocale); |
| |
| show(CFSTR("Capitalized : %@"), strChange); |
| |
| CFStringUppercase(strChange, curLocale); |
| |
| show(CFSTR("Up Cased (again) : %@"), strChange); |
| |
| CFStringFindAndReplace(strChange, find2, replace2, CFRangeMake(0, CFStringGetLength(strChange)), 0); |
| |
| show(CFSTR("Replaced? : %@"), strChange); |
| |
| CFStringFindAndReplace(strChange, find2, replace2, CFRangeMake(0, CFStringGetLength(strChange)), kCFCompareCaseInsensitive); |
| |
| show(CFSTR("Case insensitive : %@"), strChange); |
| |
| CFStringCapitalize(strChange, curLocale); |
| |
| show(CFSTR("Capitalized : %@"), strChange); |
| |
| CFStringFindAndReplace(strChange, replace2, find2, CFRangeMake(0, CFStringGetLength(strChange)), kCFCompareAnchored); |
| |
| show(CFSTR("Should Be Unchanged: %@"), strChange); |
| |
| CFStringFindAndReplace(strChange, find3, replace3, CFRangeMake(0, CFStringGetLength(strChange)), kCFCompareAnchored|kCFCompareBackwards); |
| |
| show(CFSTR("Should Be Changed : %@"), strChange); |
| |
| show(CFSTR("Which is bigger %@ or %@?"), bigger, smaller); |
| |
| comp = CFStringCompare(bigger, smaller, 0); |
| result = (comp == kCFCompareGreaterThan) ? bigger : smaller; |
| show(CFSTR("Base Compare Says : %@"), result); |
| |
| comp = CFStringCompare(bigger, smaller, kCFCompareNumerically); |
| result = (comp == kCFCompareGreaterThan) ? bigger : smaller; |
| show(CFSTR("Numerical Compare : %@"), result); |
| |
| CFRelease(curLocale); |
| CFRelease(replace); |
| CFRelease(find); |
| CFRelease(replace2); |
| CFRelease(find2); |
| CFRelease(replace3); |
| CFRelease(find3); |
| CFRelease(bigger); |
| CFRelease(smaller); |
| CFRelease(strChange); |
| } |
| |
| Boolean equalValues(CFStringRef number, CFNumberRef expected, CFNumberFormatterStyle style, CFNumberFormatterOptionFlags option) |
| { |
| //CFStringRef enLocaleIdentifier = CFSTR("en_US"); |
| //CFLocaleRef curLocale = CFLocaleCreate(NULL, enLocaleIdentifier); |
| |
| CFLocaleRef curLocale = CFLocaleCopyCurrent(); |
| CFStringRef identifier = CFLocaleGetIdentifier(curLocale); |
| CFNumberFormatterRef fmt; |
| CFNumberRef val; |
| |
| show(CFSTR("Make a Number from : %@"), number); |
| |
| fmt = CFNumberFormatterCreate (0, curLocale, style); |
| val = CFNumberFormatterCreateNumberFromString(0, fmt, number, 0, option); |
| |
| show(CFSTR("val=%@, should be=%@\n"), val, expected); |
| |
| if (!val) |
| return false; |
| |
| return (0 == CFNumberCompare(val, expected, 0)); |
| } |
| |
| void stringHandling(void) { |
| |
| CFStringRef number; |
| int theValue = 80; |
| double theOtherValue = 123.26; |
| CFNumberRef expected = CFNumberCreate(0, kCFNumberIntType, &theValue); |
| |
| show(CFSTR("------------------Number Magic---------------")); |
| show(CFSTR("1. Integer Parsing")); |
| show(CFSTR(" (a) Decimal Style")); |
| |
| number = CFStringCreateWithCString(NULL, "80.0", kCFStringEncodingASCII); |
| if (equalValues(number, expected, kCFNumberFormatterDecimalStyle, kCFNumberFormatterParseIntegersOnly)) |
| show(CFSTR("correct.")); |
| else |
| show(CFSTR("WRONG!!!")); |
| |
| show(CFSTR(" (b) Currency Style")); |
| CFRelease(number); |
| number = CFStringCreateWithCString(NULL, "$80.00", kCFStringEncodingASCII); |
| if (equalValues(number, expected, kCFNumberFormatterCurrencyStyle, kCFNumberFormatterParseIntegersOnly)) |
| show(CFSTR("correct.")); |
| else |
| show(CFSTR("WRONG!!!")); |
| |
| show(CFSTR(" (c) Percent Style (does not work for integers)")); |
| CFRelease(number); |
| number = CFStringCreateWithCString(NULL, "80%", kCFStringEncodingASCII); |
| if (equalValues(number, expected, kCFNumberFormatterPercentStyle, kCFNumberFormatterParseIntegersOnly)) |
| show(CFSTR("correct.")); |
| else |
| show(CFSTR("WRONG!!!")); |
| |
| show(CFSTR(" (d) Scientific Notation Style (does not work for integers)")); |
| CFRelease(number); |
| number = CFStringCreateWithCString(NULL, "8.0E1", kCFStringEncodingASCII); |
| if (equalValues(number, expected, kCFNumberFormatterScientificStyle, kCFNumberFormatterParseIntegersOnly)) |
| show(CFSTR("correct.")); |
| else |
| show(CFSTR("WRONG!!!")); |
| |
| show(CFSTR(" (e) Spell-Out Style")); |
| CFRelease(number); |
| number = CFStringCreateWithCString(NULL, "eighty", kCFStringEncodingASCII); |
| if (equalValues(number, expected, kCFNumberFormatterSpellOutStyle, kCFNumberFormatterParseIntegersOnly)) |
| show(CFSTR("correct.")); |
| else |
| show(CFSTR("WRONG!!!")); |
| |
| show(CFSTR(" (f) No Style (decimal)")); |
| CFRelease(number); |
| number = CFStringCreateWithCString(NULL, "80.0", kCFStringEncodingASCII); |
| if (equalValues(number, expected, kCFNumberFormatterNoStyle, kCFNumberFormatterParseIntegersOnly)) |
| show(CFSTR("correct.")); |
| else |
| show(CFSTR("WRONG!!!")); |
| |
| show(CFSTR(" (g) No Style (spell out) (is not expected to work)")); |
| CFRelease(number); |
| number = CFStringCreateWithCString(NULL, "eighty", kCFStringEncodingASCII); |
| if (equalValues(number, expected, kCFNumberFormatterNoStyle, kCFNumberFormatterParseIntegersOnly)) |
| show(CFSTR("correct.")); |
| else |
| show(CFSTR("WRONG!!!")); |
| |
| show(CFSTR("2. Decimal Parsing")); |
| show(CFSTR(" (a) Decimal Style")); |
| |
| CFRelease(expected); |
| expected = CFNumberCreate(0, kCFNumberDoubleType, &theOtherValue); |
| |
| CFRelease(number); |
| number = CFStringCreateWithCString(NULL, "123.26", kCFStringEncodingASCII); |
| if (equalValues(number, expected, kCFNumberFormatterDecimalStyle, 0)) |
| show(CFSTR("correct.")); |
| else |
| show(CFSTR("WRONG!!!")); |
| |
| show(CFSTR(" (b) Currency Style")); |
| CFRelease(number); |
| number = CFStringCreateWithCString(NULL, "$123.26", kCFStringEncodingASCII); |
| if (equalValues(number, expected, kCFNumberFormatterCurrencyStyle, 0)) |
| show(CFSTR("correct.")); |
| else |
| show(CFSTR("WRONG!!!")); |
| |
| show(CFSTR(" (c) Percent Style")); |
| CFRelease(number); |
| number = CFStringCreateWithCString(NULL, "123.26%", kCFStringEncodingASCII); |
| if (equalValues(number, expected, kCFNumberFormatterPercentStyle, 0)) |
| show(CFSTR("correct.")); |
| else |
| show(CFSTR("WRONG!!!")); |
| |
| show(CFSTR(" (d) Scientific Notation Style")); |
| CFRelease(number); |
| number = CFStringCreateWithCString(NULL, "1.2326e2", kCFStringEncodingASCII); |
| if (equalValues(number, expected, kCFNumberFormatterScientificStyle, 0)) |
| show(CFSTR("correct.")); |
| else |
| show(CFSTR("WRONG!!!")); |
| |
| show(CFSTR(" (e) Spell-Out Style")); |
| CFRelease(number); |
| number = CFStringCreateWithCString(NULL, "one hundred twenty-three point two six", kCFStringEncodingASCII); |
| if (equalValues(number, expected, kCFNumberFormatterSpellOutStyle, 0)) |
| show(CFSTR("correct.")); |
| else |
| show(CFSTR("WRONG!!!")); |
| |
| show(CFSTR(" (f) No Style (decimal)")); |
| CFRelease(number); |
| number = CFStringCreateWithCString(NULL, "123.26", kCFStringEncodingASCII); |
| if (equalValues(number, expected, kCFNumberFormatterNoStyle, 0)) |
| show(CFSTR("correct.")); |
| else |
| show(CFSTR("WRONG!!!")); |
| |
| show(CFSTR(" (g) No Style (spell-out) (not expected to work)")); |
| CFRelease(number); |
| number = CFStringCreateWithCString(NULL, "one hundred twenty three point two six", kCFStringEncodingASCII); |
| if (equalValues(number, expected, kCFNumberFormatterNoStyle, 0)) |
| show(CFSTR("correct.")); |
| else |
| show(CFSTR("WRONG!!!")); |
| |
| CFRelease(number); |
| } |
| |
| int main () { |
| simpleStringExample(); |
| stringGettingContentsAsCStringExample(); |
| stringGettingAtCharactersExample(); |
| stringWithExternalContentsExample(); |
| stringManipulation(); |
| stringHandling(); |
| |
| return 0; |
| } |
| |
| |