面试宝典----static函数

最新推荐文章于 2022-05-10 19:46:32 发布

lusic01

最新推荐文章于 2022-05-10 19:46:32 发布

阅读量203

点赞数

所以static函数的作用域是本源文件，把它想象为面向对象中的private函数就可以了。

下面是一些示例：

file1.h如下：

[cpp] view plain copy

#include <stdio.h>
static int called();
void printStr();

file1.c如下：

[cpp] view plain copy

#include "file1.h"
static int called()
{
return 6;
}
void printStr()
{
int returnVal;
returnVal = called();
printf("returnVal=%d\n",returnVal);
}

file2.c中调用file1.h中声明的两个函数，此处我们故意调用called():

[cpp] view plain copy

#include "file1.h"
int main()
{
int val;
val = called();
printStr();
return 0;
}

编译时会报错：

[liujx@server235 static]$ gcc -Wall file2.c file1.c -o file2
file1.h:3: 警告：‘called’ 使用过但从未定义
/tmp/ccyLuBZU.o: In function `main':
file2.c:(.text+0x12): undefined reference to `called'
collect2: ld 返回 1
因为引用了file1.h中的static函数，所以file2.c中提示找不到这个函数:undefined reference to 'called'

下面修改file2.c:

[cpp] view plain copy

#include "file1.h"
int main()
{
printStr();
return 0;
}

编译运行：

[liujx@server235 static]$ gcc -Wall file2.c file1.c -o file2
[liujx@server235 static]$ ./file2
returnVal=6

static函数可以很好地解决不同原文件中函数同名的问题，因为一个源文件对于其他源文件中的static函数是不可见的。

有疏漏的地方望各位多多指教~~

//c++语言 静态成员数据和静态方法
//对象与对象之间的成员变量是相互独立的.要想共用数据,则需要使用静态成员或静态方法
//#只要在类中声明静态成员变量,即使不定义对象,也可以为静态成员变量分配空间,进而可以使用静态成员变量.(因为静态成员变量在对象创建之前就已经被分配了内存空间)
//#静态成员变量虽然在类中,但它并不是随对象的建立而分配空间的,也不是随对象的撤销而释放(一般的成员在对象建立时会分配空间,在对象撤销时会释放).静态成员变量是在程序编译时分配空间,而在程序结束时释放空间.
//#初始化静态成员变量要在类的外面进行.初始化的格式如下:数据类型 类名::静态成员变量名 = 初值;
//#不能用参数初始化表,对静态成员变量进行初始化.
//#即可以通过类名来对静态成员变量进行引用,也可以通过对象名来对静态成员变量进行引用.

#include "stdafx.h"
#include <iostream>
using namespace std;
class CShop
{
public:
    CShop(int size);
    void ShowSize();
    static void ShowPrice(); //声明静态成员函数用来显示价格
    static int ChangePrice(int price); //声明静态成员函数用来更改价格
private:
    int m_size; //声明一个私有成员变量
    static int m_price; //声明一个私有静态成员变量
};
CShop::CShop(int size)
{
    m_size = size;
}

http://pythonschool.com/python/91.html
void CShop::ShowSize()
{
    cout << "商品数量:" << m_size << endl;
}
void CShop::ShowPrice()
{
    cout << "商品价格:" << m_price << endl;
}
int CShop::ChangePrice(int price)
{
    m_price = price;
    return m_price;
}
int CShop::m_price = 100; //初始化静态成员变量

int main(int argc, char * argv[])
{
    CShop::ShowPrice();
    CShop::ChangePrice(200);
    CShop::ShowPrice();
    CShop shop(50);

    shop.ShowSize();
    shop.ShowPrice();

    return 0;
}
//普通成员函数和静态成员函数的区别是:普通成员函数在参数传递时编译器会隐藏地传递一个this指针.通过this指针来确定调用类产生的哪个对象;但是静态成员函数没有this指针,不知道应该访问哪个对象中的数据,所以在程序中不可以用静态成员函数访问类中的普通变量.










C++中的explicit
编辑
  
  
   
   C++中， 一个参数的
   
   构造函数(或者除了第一个参数外其余参数都有默认值的多参构造函数)， 承担了两个角色。 1 是个
   
   构造器 ，2 是个默认且隐含的类型转换操作符。
  
  
  
  
   
   所以， 有时候在我们写下如 AAA = XXX， 这样的代码， 且恰好XXX的类型正好是AAA单参数构造器的参数类型， 这时候
   
   编译器就自动调用这个构造器， 创建一个AAA的对象。
  
  
  
  
   
   这样看起来好象很酷， 很方便。 但在某些情况下（见下面权威的例子）， 却违背了我们（程序员）的本意。 这时候就要在这个构造器前面加上explicit修饰， 指定这个构造器只能被明确的调用/使用， 不能作为类型转换操作符被隐含的使用。
  
  
  
  
   
   explicit
   
   构造函数的作用
  
  
  
  
   
   解析：
  
  
  
  
   
   explicit构造函数是用来防止隐式转换的。请看下面的代码：
  
  
  
  
   
   
    
     
        
          1 
         
        
          2 
         
        
          3 
         
        
          4 
         
        
          5 
         
        
          6 
         
        
          7 
         
        
          8 
         
        
          9 
         
        
          10 
         
        
          11 
         
        
          12 
         
        
          13 
         
        
          14 
         
        
          15 
         
        
          16 
         
        
          17 
         
        
          18 
         
        
          19 
         
        
          20 
         
        
          21 
         
        
          22 
         
        
          23 
         
        
          24 
         
        
          25 
         
        
          26 
         
        
          27 
         
         
          
          class  
          Test1 
          
          
          { 
          
          
          public 
          : 
          
          
               
          Test1( 
          int  
          n) 
          
          
               
          { 
          
          
                   
          num=n; 
          
          
               
          } 
          //普通构造函数 
          
          
          private 
          : 
          
          
               
          int  
          num; 
          
          
          }; 
          
          
          class  
          Test2 
          
          
          { 
          
          
          public 
          : 
          
          
               
          explicit  
          Test2( 
          int  
          n) 
          
          
               
          { 
          
          
                   
          num=n; 
          
          
               
          } 
          //explicit(显式)构造函数 
          
          
          private 
          : 
          
          
               
          int  
          num; 
          
          
          }; 
          
          
          int  
          main() 
          
          
          { 
          
          
               
          Test1 t1=12; 
          //隐式调用其构造函数,成功 
          
          
               
          Test2 t2=12; 
          //编译错误,不能隐式调用其构造函数 
          
          
               
          Test2 t2(12); 
          //显式调用成功 
          
          
               
          return  
          0; 
          
          
          } 
          
        
   
   
  
  
  
  
   
   Test1的
   
   构造函数带一个int型的参数，代码23行会隐式转换成调用Test1的这个构造函数。而Test2的构造函数被声明为explicit（显式），这表示不能通过隐式转换来调用这个构造函数，因此代码24行会出现编译错误。
  
  
  
  
   
   普通构造函数能够被
   
   隐式调用。而explicit构造函数只能被显式调用。
  
  
  
  

  
  
  
  

  
  
  
  
   
   //.h中方法声明如下：
class Mouse{
    staic void Mouse::hide();
}
//在main函数中调用：
main(){
    //Mouse.hide();//报错，因为这个函数是类公用的，他没有this指针。
    Mouse::hide();//正确
}