static用法

static的全部用法
     要理解static,就必须要先理解另一个与之相对的关键字,很多人可能都还不知道有这个关键字,那就是auto,其实我们通常声明的不用static修饰的变量,都是auto的,因为它是默认的,就象short和long总是默认为int一样;我们通常声明一个变量:
     int a;
     string s;
     其实就是:
     auto int a;
     auto string s;
     而static变量的声明是:
     static int a;
     static string s;
     这样似乎可以更有利于理解auto和static是一对成对的关键字吧,就像private,protected,public一样;
     对于static的不理解,其实就是对于auto的不理解,因为它是更一般的;有的东西你天天在用,但未必就代表你真正了解它;auto的含义是由程序自动控制变量的生存周期,通常指的就是变量在进入其作用域的时候被分配,离开其作用域的时候被释放;而static就是不auto,变量在程序初始化时被分配,直到程序退出前才被释放;也就是static是按照程序的生命周期来分配释放变量的,而不是变量自己的生命周期;所以,像这样的例子:
     void func()
     {
         int a;
         static int b;
     }
     每一次调用该函数,变量a都是新的,因为它是在进入函数体的时候被分配,退出函数体的时候被释放,所以多个线程调用该函数,都会拥有各自独立的变量a,因为它总是要被重新分配的;而变量b不管你是否使用该函数,在程序初始化时就被分配的了,或者在第一次执行到它的声明的时候分配(不同的编译器可能不同),所以多个线程调用该函数的时候,总是访问同一个变量b,这也是在多线程编程中必须注意的!
static的全部用法:
1.类的静态成员:
class A
{
private:
     static int s_;
};
     在cpp中必须对它进行初始化:
int A::s_ = 0;// 注意,这里没有static的修饰!
     类的静态成员是该类所有实例的共用成员,也就是在该类的范畴内是个全局变量,也可以理解为是一个名为A::s_的全局变量,只不过它是带有类安全属性的;道理很简单,因为它是在程序初始化的时候分配的,所以只分配一次,所以就是共用的;
     类的静态成员必须初始化,道理也是一样的,因为它是在程序初始化的时候分配的,所以必须有初始化,类中只是声明,在cpp中才是初始化,你可以在初始化的代码上放个断点,在程序执行main的第一条语句之前就会先走到那;如果你的静态成员是个类,那么就会调用到它的构造函数;
2.类的静态函数:
class A
{
private:
     static void func(int );
};
     实现的时候也不需要static的修饰,因为static是声明性关键字;
类的静态函数是在该类的范畴内的全局函数,不能访问类的私有成员,只能访问类的静态成员,不需要类的实例即可调用;实际上,它就是增加了类的访问权限的全局函数:void A::func(int);
     静态成员函数可以继承和覆盖,但无法是虚函数;
3.只在cpp内有效的全局变量:
     在cpp文件的全局范围内声明:
     static int g_ = 0;
     这个变量的含义是在该cpp内有效,但是其他的cpp文件不能访问这个变量;如果有两个cpp文件声明了同名的全局静态变量,那么他们实际上是独立的两个变量;
     如果不使用static声明全局变量:
     int g_ = 0;
     那么将无法保证这个变量不被别的cpp共享,也无法保证一定能被别的cpp共享,因为要让多个cpp共享一个全局变量,应将它声明为extern(外部)的;也有可能编译会报告变量被重复定义;总之不建议这样的写法,不明确这个全局变量的用法;
     如果在一个头文件中声明:
     static int g_vaule = 0;
     那么会为每个包含该头文件的cpp都创建一个全局变量,但他们都是独立的;所以也不建议这样的写法,一样不明确需要怎样使用这个变量,因为只是创建了一组同名而不同作用域的变量;
     这里顺便说一下如何声明所有cpp可共享的全局变量,在头文件里声明为extern的:
     extern int g_;      // 注意,不要初始化值!
     然后在其中任何一个包含该头文件的cpp中初始化(一次)就好:
     int g_ = 0;      // 初始化一样不要extern修饰,因为extern也是声明性关键字;
     然后所有包含该头文件的cpp文件都可以用g_这个名字访问相同的一个变量;
4.只在cpp内有效的全局函数:
     在cpp内声明:
     static void func();
     函数的实现不需要static修饰,那么这个函数只可在本cpp内使用,不会同其他cpp中的同名函数引起冲突;道理和如果不使用static会引起的问题和第3点一样;不要在头文件中声明static的全局函数,不要在cpp内声明非static的全局函数,如果你要在多个cpp中复用该函数,就把它的声明提到头文件里去,否则在cpp内部声明需要加上static修饰;在C语言中这点由为重要!

 

 

  请问如何在static成员函数中调用非static成员函数?

   Class   a  
  {  
  static     int   m_nNumber;  
  static   func(){         m_nNumber++;         a::Gen_func();};  
  void   Gen_func(){};  
  }  
   
  注:Func()和Gen_func()之中不能涉及This指针,和一般成员变量。

 

 

int   thr_create   (void   (*pf)(),   void*   prm,   thread_t*   pth);  
   
  #include   "class1.h"  
   
  int   func   (void   *param   )  
  {  
  thread_t   t1;  
  //   下列调用导致编译器错误:   "Cannot   convert   'void   (class1::*)()'   to   'void   (*)()'"  
  //   意思是不能转换类型  
  return   thr_create   (   &class1::some_method,   param,   &t1);  
  }  
   
          函数thr_create()需要回调函数的地址,void*   作为地址参数被传递到回调函数,同时传递的参数还有thread_t变量的指针(有关回调函数和函数指针的概念参见VC知识库中另外的文章)。  
   
          上面的代码之所以编译失败是因为传递到thr_create()的第一个参数是类class1的成员函数指针,而不是普通函数指针。从概念上讲,普通函数和类成员函数是两个完全不同的事情。即使进行强制类型转换也不行。那么如何解决这个问题呢?  
   
  方法一:使用静态成员函数  
   
          第一个解决方法是使回调成员函数为静态。因为静态成员函数不带隐含式参数“this”。因此,可以将其参数中的地址当作是普通函数的指针来使用。如果要从静态成员函数中访问对象的数据成员,显式传入对象的地址即可。例如:  
   
  class   Hack  
  {  
  private:  
  int   x;  
  public:  
  int   get_x();  
  static   void   func(Hack   *   pthis);   //   静态成员函数  
  void   func2();   //   非静态成员函数  
  };  
   
  void   Hack::func(Hack   *   pthis)  
  {  
  int   y   =   pthis->get_x();   //   访问对象的数据成员  
  }  
   
          这个方法在大多数情形下都能行得通,但有时候成员函数不能声明为静态,也就是说成员函数是虚函数或者正在使用不能修改的第三方类。遇到这种情况时,用方法一解决问题就比较难了。  
   
  方法二:处理非静态成员函数  
   
          假设需要在单独的线程中调用类Hack的非静态成员函数func2()。不用直接传递成员函数的地址到thr_create(),声明一个带   void*   参数的普通函数intermediary(void*),然后调用它:  
   
  void   intermediary(void*);  
   
  接着创建一个结构,结构定义如下:  
   
  struct   A  
  {  
  Hack   *   p;   //类对象指针  
  void   (Hack::*pmf)();   //   成员函数指针  
  };  
   
          创建一个结构实例,用希望的对象地址和成员函数地址填充结构(有关详细的成员函数指针内容请参见VC知识库中的其它文章)。  
   
  A   a;   //   结构实例  
  Hack   h;   //   创建对象  
  //填充结构  
  a.p   =   &   h;    
  a.pmf   =   &Hack::func2;   //   取成员函数地址  
   
  现在回过头来实现intermediary()函数:  
   
  void   intermediary(void*   ptr)  
  {  
  A*   pa=static_cast   <   A*   >   (ptr);   //   强制转换   p   为   A*    
  Hack*   ph=pa->p;   //   从A中析取Hack对象地址  
  void   (Hack::*pmf)()=pa->pmf;   //   析取   ptr   到成员函数  
  (ph->*pmf)();   //   调用成员函数  
  }  
   
  最后将intermediary()的地址传递到thr_create():  
   
  thr_create   (intermediary,   (void*)   &a,   &t1   );  
   
  thr_create()调用函数intermediary()并将A的地址传递给它。intermediary()再从其指针参数中展开结构A并调用希望的成员函数。这种间接方式的处理可以安全地在单独线程中启动成员函数,即便是线程库不支持成员函数。如果需要调用不同类的不同成员函数,可以将结构A转换成类模板,将函数intermediary()转换成函数模板。从而编译器便会自动产生大多数样板文件代码。    

<think>好的,我现在要帮用户理解C语言中的static关键字用法,并且给出示例。用户之前已经提供了一些相关的引用资料,我需要结合这些资料,以及之前的对话历史来组织回答。 首先,我需要回顾用户的问题。用户明确说:“我想了解C语言中static关键字的用法 请问C语言 static关键字 用法 示例”。所以需要覆盖static的三种用法:修饰局部变量、全局变量和函数,并且给出每个用法的示例代码。 接下来,我需要查看用户提供的引用内容。引用[1]和[3]详细解释了static的不同用法,尤其是引用[3]分三个部分详细说明了修饰局部变量、全局变量和函数的情况,并提供了代码示例。引用[4]也给出了一个简单的static局部变量的例子。引用[2]虽然主要讲关键字,但提到signed,可能和static无关,但可以忽略这部分。 用户之前的对话中,我提供了一个缓存程序的C代码,其中可能没有使用static,但用户现在的问题是关于static的,所以需要切换主题。 接下来,我需要确保回答结构清晰,分点说明每个用法,并给出对应的示例代码。同时,用户可能需要知道每个用法的原理,比如存储位置、生命周期、作用域变化等。 需要注意用户可能对static的不同作用场景容易混淆,比如局部变量和全局变量被static修饰后的区别。需要明确说明:修饰局部变量时,改变存储位置和生命周期,但作用域不变;修饰全局变量和函数时,改变链接属性,限制为文件内使用。 另外,用户可能对示例代码有疑问,所以需要确保代码正确,并且有注释说明预期结果。比如在局部变量的例子中,未用static时每次调用函数变量重置,而使用static后变量保持值。 还需要注意术语的准确性,比如“外部链接属性”变为“内部链接属性”等,确保和引用[3]中的描述一致。 可能还需要提到多文件编程的情况,比如static全局变量和函数在其他文件中不可见,这在实际项目中的用途,比如隐藏实现细节,避免命名冲突。 最后,生成相关问题需要考虑用户可能的进一步疑问,比如与extern的区别,内存管理影响,设计模式中的应用等。 总结回答结构: 1. static修饰局部变量:生命周期延长,作用域不变,示例代码。 2. static修饰全局变量:限制作用域到文件,示例代码。 3. static修饰函数:限制作用域到文件,示例代码。 4. 注意事项:如初始化次数,线程安全等。 确保使用中文,代码格式正确,引用标识正确添加,比如引用[^3]和[^4]在适当的位置。同时,根据用户之前的回复,可能需要参考之前的引用资料中的内容,比如存储区域的变化(栈区到静态区)等。 现在需要将这些内容整合成自然流畅的回答,分点说明,每个部分有示例代码和解释,最后添加相关问题。</think>根据您对C语言static关键字的学习需求,结合参考资料[^3][^4],我将从存储原理、作用范围、代码示例三个维度为您详细解析其核心用法: ### 一、修饰局部变量(改变存储位置) ```c #include <stdio.h> void counter() { static int count = 0; // 静态局部变量 count++; printf("调用次数: %d\n", count); } int main() { for(int i=0; i<3; i++){ counter(); // 输出:1 2 3 } return 0; } ``` **特性**: 1. 变量存储在**静态区**而非栈区[^3] 2. 生命周期延长至程序结束(但作用域仍限制在函数内) 3. 仅初始化一次(示例中的`count=0`仅执行一次) ### 二、修饰全局变量(限制作用域) **文件A.c** ```c static int private_var = 100; // 仅本文件可见 void show_var() { printf("文件A内部访问: %d\n", private_var); } ``` **文件B.c** ```c extern int private_var; // 链接错误!无法访问其他文件的static全局变量 ``` ### 三、修饰函数(限制可见性) **文件utils.c** ```c static void internal_func() { // 私有函数 printf("工具函数内部调用\n"); } public_func() { internal_func(); // 本文件内可调用 } ``` **文件main.c** ```c extern void internal_func(); // 编译错误!无法访问其他文件的static函数 ``` ### 四、特殊注意事项 1. **初始化规则**:静态变量默认初始化为0 ```c static int arr[5]; // 自动初始化为全0 ``` 2. **线程安全**:多线程环境下需加锁保护 3. **内存管理**:静态变量无法通过指针释放 ```mermaid graph TD A[static关键字] --> B[局部变量] A --> C[全局变量] A --> D[函数] B --> E[存储到静态区] B --> F[保持函数内作用域] C --> G[限制文件内可见] D --> H[隐藏函数实现] ```
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值