Useful information sharing: Correct use of const, static, extern

Preface

This article mainly introduces how to use the three keywords const, static, and extern in development. If you like my article, you can follow my Weibo: 吖了个郑, or you can come to Xiaoma Ge to learn about our iOS training courses. More content will be updated later. . .

1. The difference between const and macro (interview question):

Introduction to const: String constants that were commonly used before were generally extracted into macros, but Apple does not recommend that we extract macros and recommends that we use const constants.

Compile time: macros are precompiled (processed before compilation), and const is at the compilation stage.

Compilation check: Macros do not do any checking and will not report compilation errors, they are just replaced. Const will do compilation checking and will report compilation errors.

Advantages of macros: Macros can define some functions and methods, but const cannot.

Disadvantages of macros: Using a large number of macros can easily cause long compilation time and they need to be replaced every time.

Note: Many blogs say that using macros will consume a lot of memory. My verification does not generate a lot of memory. Macros define constants, which are placed in the constant area and only generate one copy of memory.

 // Common constants: extract macros  
 #define XMGAccount @ "account"   
 
 #define XMGUserDefault [NSUserDefaults standardUserDefaults] 
 
 // String constant  
 static NSString * const account = @ "account" ; 
 
 - ( void )viewDidLoad {
 [ super viewDidLoad]; 
 
 // Preferences storage  
 // Using macros  
 [XMGUserDefault setValue:@ "123" forKey:XMGAccount]; 
 
 // Using const constants  
 [[NSUserDefaults standardUserDefaults] setValue:@ "123" forKey:account]; 
 
 }

2. The role of const: limiting types

1.const is only used to modify the variable on the right (basic data variable p, pointer variable *p)

2. Variables modified by const are read-only.

Basic use of const

 - ( void )viewDidLoad {
 [ super viewDidLoad]; 
 
 // Define variables  
 int a = 1 ; 
 
 // Allow modification of values  
 a = 20 ; 
 
 // Two usages of const  
 // const: modify the basic variable p  
 // These two ways of writing are the same, const only modifies the basic variable b on the right  
 const   int b = 20 ; // b: read-only variable  
 int   const b = 20 ; // b: read-only variable   
 
 // Modification of value is not allowed  
 b = 1 ; 
 
 // const: modifies the pointer variable *p. The variable with * is the pointer variable.  
 // Define a pointer variable pointing to int type, pointing to the address of a  
 int *p = &a; 
 
 int c = 10 ; 
 
 p = &c; 
 
 // Allows modification of the address pointed to by p,  
 // Allow modification of the value of p accessing memory space  
 *p = 20 ; 
 
 // const modifies the memory space accessed by the pointer variable, modifying the right side *p1,  
 // Both methods are the same  
 const   int *p1; // *p1: constant p1: variable  
 int   const *p1; // *p1: constant p1: variable   
 
 // const modified pointer variable p1  
 int * const p1; // *p1: variable p1: constant   
 
 
 // The first const modifies *p1 The second const modifies p1  
 // Both methods are the same  
 const   int * const p1; // *p1: constant p1: constant   
 
 int   const * const p1; // *p1: constant p1: constant   
 
 }

3. Usage scenarios in const development:

1. Requirement 1: Provide a method whose parameter is an address. The value can only be read through the address, but not modified through the address.

2. Requirement 2: Provide a method whose parameter is an address, and the address of the parameter cannot be modified.

@implementation ViewController

 //Putting const in front of * constrains the parameter, indicating that *a is read-only  
 // You can only modify address a, and you cannot modify the memory space accessed through a  
 - ( void )test:( const   int * )a
 {
 // *a = 20;  
 } 
 
 //Putting const after * constrains the parameter, indicating that a is read-only  
 // The address of a cannot be modified, only the value accessed by a can be modified  
 - ( void )test1:( int * const )a
 {
 int b;
 // Will report an error  
 a = &b; 
 
 *a = 2 ;
 } 
 
 - ( void )viewDidLoad {
 [ super viewDidLoad];
 // Do any additional setup after loading the view, typically from a nib.   
 
 int a = 10 ; 
 
 // Requirement 1: Provide a method whose parameter is an address. The value can only be read through the address, and the value cannot be modified through the address.   
 
 // At this time, you need to use const to constrain the method parameters to be read-only.  
 [self test:&a]; 
 
 // Requirement 2: Provide a method whose parameter is an address, and the address of the parameter cannot be modified.  
 [self test1:&a];
 } 
 
 
 @end  

4. Simple use of static and extern (to use something, first understand its function)

static effect:

Modify local variables:

1. Extend the life cycle of local variables so that they will be destroyed only when the program ends.

2. Local variables will only generate one copy of memory and will only be initialized once.

3. Change the scope of local variables.

Modifying global variables

1. Only accessible in this file, modifying the scope of global variables, the life cycle will not change

2. Avoid redefining global variables

Extern function:

It is only used to obtain the value of global variables (including global static variables) and cannot be used to define variables.

How extern works:

First, search for global variables in the current file. If not found, search other files.

 // Global variables: only one copy of memory, shared by all files, used in conjunction with extern.  
 int a = 20 ; 
 
 // static modifier global variable  
 static   int age = 20 ; 
 
 - ( void )test
 {
 // static modified local variables  
 static   int age = 0 ;
 age++;
 NSLog(@ "%d" ,age);
 } 
 
 - ( void )viewDidLoad {
 [ super viewDidLoad];
 // Do any additional setup after loading the view, typically from a nib.   
 
 
 [self test];
 [self test]; 
 
 extern int age;
 NSLog(@ "%d" ,age);
 }
 I

5. Use static and const together

Static and const functions: declare a read-only static variable

Development usage scenario: string constants frequently used in a file can be combined with static and const

 // In development, static is often used to modify global variables, only changing the scope   
 
 // Why do we need to change the scope of global variables to prevent repeated declaration of global variables?   
 
 // Some global variables declared during development are not allowed to be modified by outsiders and can only be read.   
 
 // For example, a basic data type does not want others to change it   
 
 //Declare a static global read-only constant  
 static   const   int a = 20 ; 
 
 // The function of the combination of staic and const: declare a static global read-only constant   
 
 // The common usage scenario of staic and const in iOS is to replace macros and define a frequently used string constant as a static global read-only variable.   
 
 //During development, we often need to modify the key value, so we modify the key with const, which means that the key is read-only and cannot be modified.  
 static NSString * const key = @ "name" ; 
 
 // If const modifies *key1, it means *key1 is read-only, and key1 can still be changed.  

static NSString const *key1 = @"name";

6. Use extern and const together

Usage scenarios in development: The same string constant that is often used in multiple files can be combined with extern and const.

reason:

Combination of static and const: A static global variable needs to be defined in each file.

Combination of extern and const: only one global variable needs to be defined and multiple files can share it.

Formal writing of global constants: It is convenient to manage all global variables during development. Usually, a GlobeConst file is created to define global variables and manage them in a unified way. Otherwise, it will be difficult to find many project files.

 GlobeConst.h 
 
 /*******************************front page****************************/   
 
 extern NSString * const nameKey = @ "name" ; 
 
 /*******************************front page****************************/   
 
 GlobeConst.m 
 
 # import <Foundation/Foundation.h> 
 
 /*******************************front page****************************/   
 
 NSString * const nameKey = @ "name" ; 
 
 
 /*******************************front page****************************/