精华内容
下载资源
问答
  • C++ static.pdf

    2021-09-14 10:40:23
    C++ static.pdf
  • c++ static.pdf

    2021-08-26 11:27:48
    c++ static.pdf
  • C++ static 用法总结

    2011-08-23 21:22:58
    C++ static 用法总结C++ static 用法总结
  • C++ static静态成员.pdf

    2021-09-14 10:40:23
    C++ static静态成员.pdf
  • 在这里我们就为大家详细介绍一下C++ static关键字的使用方法,让大家进一步对这一语言有一个深入的解读。
  • C++ Static关键字作用介绍

    千次阅读 2021-06-25 13:14:58
    C++ Static前言1.全局静态变量2.局部静态变量3.静态函数4.类的静态成员5.类的静态函数 前言 Static一共有哪些用法呢? 1.全局静态变量 在全局变量前加上关键字static,全局变量就定义成一个全局静态变量。 **内存中...

    原创文章,转载请注明出处。

    前言

    Static一共有哪些用法呢?

    1.全局静态变量

    在全局变量前加上关键字static,全局变量就定义成一个全局静态变量。
    
    **内存中的位置:** 静态存储区,在整个程序运行期间一直存在。
    
    **初始化**:未经初始化的全局静态变量会被自动初始化为0(自动对象的值是任意的,除非他被显式初始化);
    
    **作用域**:全局静态变量在声明他的文件之外是不可见的,准确地说是从定义之处开始,到文件结尾。
    

    2.局部静态变量

    在局部变量之前加上关键字static,局部变量就成为一个局部静态变量。
    
    内存中的位置:静态存储区
    
    初始化:未经初始化的全局静态变量会被自动初始化为0(自动对象的值是任意的,除非他被显式初始化);
    
    作用域:作用域仍为局部作用域,当定义它的函数或者语句块结束的时候,作用域结束。但是当局部静态变量离开作用域后,并没有销毁,而是仍然驻留在内存当中,只不过我们不能再对它进行访问,直到该函数再次被调用,并且值不变;
    

    3.静态函数

    在函数返回类型前加static,函数就定义为静态函数。函数的定义和声明在默认情况下都是extern的,
    但静态函数只是在声明他的文件当中可见,不能被其他文件所用。
    
    函数的实现使用static修饰,那么这个函数只可在本cpp内使用,不会同其他cpp中的同名函数引起冲突;
    
    warning:不要再头文件中声明static的全局函数,不要在cpp内声明非static的全局函数,
    如果你要在多个cpp中复用该函数,就把它的声明提到头文件里去,否则cpp内部声明需加上static修饰;
    

    4.类的静态成员

    在类中,静态成员可以实现多个对象之间的数据共享,并且使用静态数据成员还不会破坏隐藏的原则,
    即保证了安全性。因此,静态成员是类的所有对象中共享的成员,而不是某个对象的成员。
    对多个对象来说,静态数据成员只存储一处,供所有对象共用
    

    5.类的静态函数

    静态成员函数和静态数据成员一样,它们都属于类的静态成员,它们都不是对象成员。
    因此,对静态成员的引用不需要用对象名。
    
    在静态成员函数的实现中不能直接引用类中说明的非静态成员,可以引用类中说明的静态成员(这点非常重要)。
    如果静态成员函数中要引用非静态成员时,可通过对象来引用。从中可看出,调用静态成员函数使用如下格式:
    <类名>::<静态成员函数名>(<参数表>);
    

    谢谢,创作不易,大侠请留步… 动起可爱的双手,来个赞再走呗 <( ̄︶ ̄)>

    展开全文
  • C++ static关键字作用

    千次阅读 多人点赞 2019-06-18 16:04:14
    C++ static关键字作用 1.static修饰全局变量 当同时编译多个文件时,所有未加static前缀的全局变量和函数都具有全局可见性,其它的源文件也能访问。 未加static的全局变量,在符号表中是global符号,其他目标文件...

    C++ static关键字作用

    1.static修饰全局变量

    当同时编译多个文件时,所有未加static前缀的全局变量和函数都具有全局可见性,其它的源文件也能访问。

    未加static的全局变量,在符号表中是global符号,其他目标文件可见,这样的符号是要参与符号解析的。加了static之后,是local符号,其他目标文件不可见,只在当前文件中可见,不参与符号解析过程。所以多个源文件可以定义同名的static全局变量,不会产生重定义错误。

    修饰全局变量是改变变量的作用域,让它只能在本文件中使用。

    2. 修饰局部变量时使它放在.data 或者.bss段,默认初始化为0,初始化不为0放在.data段,没有初始化或初始化为0放在.bss段。程序一运行起来就给他分配内存,并进行初始化,也是唯一一次初始化。它的生存期为整个源程序,程序结束,它的内存才释放。但是其作用域仍与自动变量相同,只能在定义该变量的函数内使用该变量。退出该函数后, 尽管该变量还继续存在,但不能使用它。

    修饰局部变量是改变它的生存期,变为和整个程序的生命周期一样。

    3.修饰普通函数时,和修饰全局变量一样。函数经过编译产生一个函数符号,被static修饰后,就变为local符号,不参与符号解析,只在本文件中可见。

    4、修饰类的成员变量时。就变成静态成员变量,不属于对象,而属于类。不能在类的内部初始化,类中只能声明,定义需要在类外。类外定义时,不用加static关键字,只需要表明类的作用域。

      修饰类的成员函数时。变成静态成员函数,也不属于对象,属于类。形参不会生成this指针,仅能访问类的静态数据和静态成员函数。调用不依赖对象,所以不能作为虚函数。用类的作用域调用。

     

    如果你希望在一个函数中对一个变量只执行一次初始化,以后不再初始化,使用上一次结果,就应该使用静态局部变量。
    例如: static int n; 
    其他类型都可以。

     

     

    展开全文
  • C++ static静态成员变量用法

    千次阅读 2019-09-28 22:47:25
    C++ static静态成员变量用法 参考网址: 1、http://c.biancheng.net/cpp/biancheng/view/209.html 2、https://www.runoob.com/cplusplus/cpp-static-members.html c++中: 1、在.h文件的类中定义静态的public ...

    C++ static静态成员变量用法

    参考网址:

    1、http://c.biancheng.net/cpp/biancheng/view/209.html

    2、https://www.runoob.com/cplusplus/cpp-static-members.html

    c++中:

    1、在.h文件的类中定义静态的public 变量

    public:

    static int m_total; //静态成员变量

    2、在.cpp中的开头进行初始化,初始化时需要加上类的作用域type class::name

    static 成员变量必须在类声明的外部初始化,具体形式为:

    type class::name = value;

    type 是变量的类型,class 是类名,name 是变量名,value 是初始值。将上面的 m_total 初始化:

    int Student::m_total = 0;

    静态成员变量在初始化时不能再加 static

    展开全文
  • C++ static、const和static const 以及它们的初始化 const定义的常量在超出其作用域之后其空间会被释放,而static定义的静态常量在函数执行后不会释放其存储空间。 static表示的是静态的。类的静态成员函数、静态...

    下面的文章是我从网上找了好久,整理了好久的,对我有很大帮助,原址已经记不住了,算我自己原创的了哇!

    C++ staticconststatic const 以及它们的初始化

    const定义的常量在超出其作用域之后其空间会被释放,而static定义的静态常量在函数执行后不会释放其存储空间

    static表示的是静态的。类的静态成员函数、静态成员变量是和类相关的,而不是和类的具体对象相关的。即使没有具体对象,也能调用类的静态成员函数和成员变量。一般类的静态函数几乎就是一个全局函数,只不过它的作用域限于包含它的文件中。

    在C++中,static静态成员变量不能在类的内部初始化。在类的内部只是声明,定义必须在类定义体的外部,通常在类的实现文件中初始化,如:double Account::Rate = 2.25;static关键字只能用于类定义体内部的声明中,定义时不能标示为static

    在C++中,const成员变量也不能在类定义处初始化,只能通过构造函数初始化列表进行,并且必须有构造函数。

    const数据成员 只在某个对象生存期内是常量,而对于整个类而言却是可变的因为类可以创建多个对象,不同的对象其const数据成员的值可以不同。所以不能在类的声明中初始化const数据成员,因为类的对象没被创建时,编译器不知道const数据成员的值是什么。

    const数据成员的初始化只能在类的构造函数的初始化列表中进行。要想建立在整个类中都恒定的常量,应该用类中的枚举常量来实现,或者static cosnt。

    class Test{
    public:
    	Test():a(0){}
    	enum {size1=100,size2=200};
    private:
    	const int a;//只能在构造函数初始化列表中初始化
    	static int b;//在类的实现文件中定义并初始化
    	conststatic int c;//与 static const int c;相同。
    };
     
    int Test::b=0;//static成员变量不能在构造函数初始化列表中初始化,因为它不属于某个对象。
    cosnt intTest::c=0;//注意:给静态成员变量赋值时,不需要加static修饰符,但要加cosnt。
    
    

    cosnt成员函数主要目的是防止成员函数修改对象的内容。即const成员函数不能修改成员变量的值,但可以访问成员变量。当方法成员函数时,该函数只能是const成员函数。

    static成员函数主要目的是作为类作用域的全局函数。不能访问类的非静态数据成员。类的静态成员函数没有this指针,这导致:1、不能直接存取类的非静态成员变量,调用非静态成员函数2、不能被声明为virtual

     

    关于static、const、static cosnt、const static成员的初始化问题:

    1、类里的const成员初始化:

    在一个类里建立一个const时,不能给他初值

    class foo{
    public:
    	foo():i(100){}
    private:
    	const int i=100;//error!!!
    };
    //或者通过这样的方式来进行初始化
    foo::foo():i(100){}

     

    2、类里的static成员初始化:

    类中的static变量是属于类的,不属于某个对象,它在整个程序的运行过程中只有一个副本,因此不能在定义对象时 对变量进行初始化,就是不能用构造函数进行初始化,其正确的初始化方法是:

    数据类型 类名::静态数据成员名=值;

    class foo{
    public:
    	foo();
    private:
    staticint i;
    };
    
    intfoo::i=20;

    .这表明:

    1、初始化在类体外进行,而前面不加static,以免与一般静态变量或对象相混淆

    2、初始化时不加该成员的访问权限控制符private、public等

    3、初始化时使用作用域运算符来表明它所属的类,因此,静态数据成员是类的成员而不是对象的成员。

     

    3、类里的static cosnt 和 const static成员初始化

    这两种写法的作用一样,为了便于记忆,在此值说明一种通用的初始化方法:

    class Test{
    public:
    	static const int mask1;
    	conststatic int mask2;
    };
    constTest::mask1=0xffff;
    constTest::mask2=0xffff;
    //它们的初始化没有区别,虽然一个是静态常量一个是常量静态。静态都将存储在全局变量区域,其实最后结果都一样。可能在不同编译器内,不同处理,但最后结果都一样。

    这是一个完整的例子:

    #ifdef A_H_
    #define A_H_
    #include <iostream>
    usingnamespace std;
    class A{
    public:
    	A(int a);
    	staticvoid print();//静态成员函数
    private:
    	static int aa;//静态数据成员的声明
    	staticconst int count;//常量静态数据成员(可以在构造函数中初始化)
    	const int bb;//常量数据成员
    };
    
    int A::aa=0;//静态成员的定义+初始化
    const int A::count=25;//静态常量成员定义+初始化
    
    A::A(int a):bb(a){//常量成员的初始化
    aa+=1;
    }
    
    void A::print(){
    cout<<"count="<<count<<endl;
    cout<<"aa="<<aa<<endl;
    }
    
    #endif
    
    void main(){
    	A a(10);
    	A::print();//通过类访问静态成员函数
    	a.print();//通过对象访问静态成员函数
    }


     

    初始化位置

    静态成员不能在类的定义里初始化(除int外)。不能在头文件里初始化。
    比如定义了 myclass.h,一般放到myclass.cpp里初始化它。

     

    C++ 类的静态成员(static)

    静态成员的提出是为了解决数据共享的问题。实现共享有许多方法,如:设置全局性的变量或对象是一种方法。但是,全局变量或对象是有局限性的。这一章里,我们主要讲述类的静态成员来实现数据的共享。

    静态数据成员

      在类中,静态成员可以实现多个对象之间的数据共享,并且使用静态数据成员还不会破坏隐藏的原则,即保证了安全性。因此,静态成员是类的所有对象中共享的成员,而不是某个对象的成员。

      使用静态数据成员可以节省内存
    ,因为它是所有对象所公有的,因此,对多个对象来说,静态数据成员只存储一处,供所有对象共用。静态数据成员的值对每个对象都是一样,但它的值是可以更新的。只要对静态数据成员的值更新一次,保证所有对象存取更新后的相同的值,这样可以提高时间效率。

      静态数据成员的使用方法和注意事项如下:

      1、静态数据成员在定义或说明时前面加关键字static。

      2、静态成员初始化与一般数据成员初始化不同。静态数据成员初始化的格式如下:

        <数据类型><类名>::<静态数据成员名>=<值>

      这表明:

            (1) 初始化在类体外进行,而前面不加static,以免与一般静态变量或对象相混淆。

      (2) 初始化时不加该成员的访问权限控制符private,public等。

      (3) 初始化时使用作用域运算符来标明它所属类,因此,静态数据成员是类的成员,而不是对象的成员。

      3、静态数据成员是静态存储的,它是静态生存期,必须对它进行初始化

      4、引用静态数据成员时,采用如下格式:

       <类名>::<静态成员名>

      如果静态数据成员的访问权限允许的话(即public的成员),可在程序中,按上述格式来引用静态数据成员。

      下面举一例子,说明静态数据成员的应用:

    #include …
    class Myclass{
    public:
    	Myclass(int a, int b, int c);
    	void GetNumber();
    	void GetSum();
    private:
    	int A, B, C;
    	static int Sum;
    };
    
    int Myclass::Sum = 0;
    
    Myclass::Myclass(int a, int b, int c){
    	A = a;
    	B = b;
    	C = c;
    	Sum += A+B+C;
    }
    
    void Myclass::GetNumber(){
    	cout<<"Number="<<a<<","<<b<<","<<c<<endl;
     }
    
    void Myclass::GetSum(){
    	cout<<"Sum="<<sum<<endl;
     }
    
    void main(){
    	Myclass M(3, 7, 10),N(14, 9, 11);
    	M.GetNumber();
    	N.GetNumber();
    	M.GetSum();
    	N.GetSum();
    }


      从输出结果可以看到Sum的值对M对象和对N对象都是相等的。这是因为在初始化M对象时,将M对象的三个int型数据成员的值求和后赋给了Sum,于是Sum保存了该值。在初始化N对象时,对将N对象的三个int型数据成员的值求和后又加到Sum已有的值上,于是Sum将保存另后的值。所以,不论是通过对象M还是通过对象N来引用的值都是一样的,即为54。

    静态成员函数

    静态成员函数和静态数据成员一样,它们都属于类的静态成员,它们都不是对象成员。因此,对静态成员的引用不需要用对象名。

      在静态成员函数的实现中不能直接引用类中说明的非静态成员,可以引用类中说明的静态成员。
    如果静态成员函数中要引用非静态成员时,可通过对象来引用。下面通过例子来说明这一点。

    #include …
    class M{
    public:
    	M(int a){
    		A=a;
    		B+=a;
    	}
    	
    	static void f1(M m);
    private:
    	int A;
    	static int B;
    };
    
    void M::f1(M m)
    {
    	cout<<"A="<<m.a<<endl;
    	cout<<"B="<<b<<endl;
    }
    
    int M::B=0;
    
    void main()
    {
    	M P(5),Q(10);
    	M::f1(P); //调用时不用对象名
    	M::f1(Q);
    }


      读者可以自行分析其结果。从中可看出,调用静态成员函数使用如下格式:

      <类名>::<静态成员函数名>(<参数表>);


     

    C++中各种类型的成员变量的初始化方法

    c++各种不同类型成员根据是否static、时候const类型的初始化方法不尽相同,java的语法就没有这么复杂,怪的得那么多人都跑去学Java了。以前面试时被人问到这个问题回答不出来,写代码时也经常搞乱了,这里翻了下书,总结一下。

    -----------------Test.h----------------------------
    #pragma once
    class Test
    {
    private :
    	int var1;
    	// int var11= 4; 错误的初始化方法
    	const int var2 ;
    	// const int var22 =22222; 错误的初始化方法
    	static int var3;
    	// static int var3333=33333; 错误,只有静态常量int成员才能直接赋值来初始化
    	static const int var4=4444; //正确,静态常量成员可以直接初始化	
    	static const int var44;
    public:
    	Test(void);
    	~Test(void);
    };
    --------------------Test.cpp-----------------------------------
    #include ".\test.h"
    
    int Test::var3 = 3333333; //静态成员的正确的初始化方法
    
    // int Test::var1 = 11111;; 错误静态成员才能初始化
    // int Test::var2 = 22222; 错误
    // int Test::var44 = 44444; // 错误的方法,提示重定义
    Test::Test(void):var1(11111),var2(22222)正确的初始化方法//var3(33333)不能在这里初始化
    {
    	var1 =11111; //正确, 普通变量也可以在这里初始化
    	//var2 = 222222; 错误,因为常量不能赋值,只能在 “constructor initializer (构造函数的初始化列表)” 那里初始化
              
    	var3 =44444; //这个赋值是正确的,不过因为所有对象一个静态成员,所以会影响到其他的,这不能叫做初始化了吧
    }
    Test::~Test(void){}
    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

    有些成员变量的数据类型比较特别,它们的初始化方式也和普通数据类型的成员变量有所不同。这些特殊的类型的成员变量包括:

        a. 常量型成员变量
        b. 引用型成员变量
        c. 静态成员变量
        d. 整型静态常量成员变量
        e. 非整型静态常量成员变量

      对于常量型成员变量和引用型成员变量的初始化,必须通过构造函数初始化列表的方式进行。在构造函数体内给常量型成员变量和引用型成员变量赋值的方式是行不通的

        静态成员变量的初始化也颇有点特别。
       参考下面的代码以及其中注释:

    // Initialization of Special Data Member
    #include <iostream>
    using namespace std;     
    
    class BClass
    {
    public:
    	BClass() : i(1),ci(2), ri(i) // 对于常量型成员变量和引用型成员变量,必须通过	
    	{				// 参数化列表的方式进行初始化。在构造函数体内进行赋值的方式,是行不通的。
    	} 
    
    	voidprint_values()
    	{
    		cout<< "i =\t" << i << endl;
    		cout<< "ci =\t" << ci << endl;
    		cout<< "ri =\t" << ri << endl;
    		cout<< "si =\t" << si << endl;
    		cout<< "csi =\t" << csi << endl;
    		cout<< "csi2 =\t" << csi2 << endl;
    		cout<< "csd =\t" << csd << endl;
    	}
    
    private:
    	inti; // 普通成员变量
    	constint ci; // 常量成员变量
    	int&ri; // 引用成员变量
    	staticint si; // 静态成员变量
    	//staticint si2 = 100; // error: 只有静态常量成员变量,才可以这样初始化
    	staticconst int csi; // 静态常量成员变量
    	staticconst int csi2 = 100; // 静态常量成员变量的初始化(Integral type) (1)
    	staticconst double csd; // 静态常量成员变量(non-Integral type)
    	//staticconst double csd2 = 99.9; // error: 只有静态常量整型数据成员才可以在类中初始化
    };
    // 静态成员变量的初始化(Integral type)
    int BClass::si = 0;
    // 静态常量成员变量的初始化(Integral type)
    const int BClass::csi = 1;
    // 静态常量成员变量的初始化(non-Integral type)
    const double BClass::csd = 99.9;
    
    // 在初始化(1)中的csi2时,根据Stanley B. Lippman的说法下面这行是必须的。
    // 但在VC2003中如果有下面一行将会产生错误,而在VC2005中,下面这行则可有可无,这个和编译器有关。
    const int BClass::csi2;
    
    int main(void)
    {
    	BClassb_class;
    	b_class.print_values(); 
    	return0;
    }
     

    c++静态成员小结,c++,static

    类中的静态成员真是个让人爱恨交加的特性。我曾经在面试时,被主考官抓住这个问题一阵穷追猛打,直把我问的面红耳赤,败下阵来。所以回来之后,我痛定思痛,决定好好总结一下静态类成员的知识点,以便自己在以后面试中,在此类问题上不在被动。 
    静态类成员包括静态数据成员和静态函数成员两部分。 

    静态数据成员

    类体中的数据成员的声明前加上static关键字,该数据成员就成为了该类的静态数据成员。和其他数据成员一样,静态数据成员也遵守public/protected/private访问规则。同时,静态数据成员还具有以下特点: 

    1.
    静态数据成员的定义。 
    静态数据成员实际上是类域中的全局变量。所以,静态数据成员的定义(初始化)不应该被放在头文件中。 声明vs.定义(初始化)
    其定义方式与全局变量相同。举例如下: 

    xxx.h文件 
    class base{ 
    private: 
        static const int _i;//声明,标准c++支持有序类型在类体中初始化,但vc6不支持。 
    }; 
    
    xxx.cpp文件 
    const int base::_i=10;//定义(初始化)时不受private和protected访问限制. 


    注:不要试图在头文件中定义(初始化)静态数据成员。在大多数的情况下,这样做会引起重复定义这样的错误。 即使加上 #ifndef #define #endif 或者 #pragma once 也不行。  

    2.
    静态数据成员被的所有对象所共享,包括该类派生类的对象。即派生类对象与基类对象共享基类的静态数据成员。 举例如下:  
    class base{ 
    public : 
    	static int _num;//声明 
    }; 
    int base::_num=0;//静态数据成员的真正定义 
    
    class derived:public base{ }; 
    
    main() 
    { 
    	base a; 
    	derived b; 
    	a._num++; 
    	cout<<"base class static data number_num is"<<a._num<<endl; 
    	b._num++; 
    	cout<<"derived class static datanumber _num is"<<b._num<<endl; 
    } 
    // 结果为1,2;可见派生类与基类共用一个静态数据成员。 



    3. 静态数据成员可以成为成员函数的 可选参数,而普通数据成员则不可以。举例如下:  
    class base{ 
    public : 
    	static int _staticVar; 
    	int _var; 
    	void foo1(int i=_staticVar);//正确,_staticVar为静态数据成员 
    	void foo2(int i=_var);//错误,_var为普通数据成员 
    }; 


    4. 静态数据成员的类型可以是所属类的类型,而普通数据成员则不可以。普通数据成员的只能声明为所属类类型的指针或引用。 举例如下:  
    class base{ 
    public : 
    	static base_object1;//正确,静态数据成员 
    	base _object2;//错误 
    	base *pObject;//正确,指针 
    	base &mObject;//正确,引用 
    }; 

    5. 这个特性,我不知道是属于标准 c++ 中的特性,还是 vc6 自己的特性。  
    静态数据成员的值在const成员函数中可以被合法的改变 。举例如下:  
    class base{ 
    public: 
    	base(){
    		_i=0;
    		_val=0;
    	} 
    
    	mutable int _i; 
    	static int _staticVal; 
    	int _val; 
    	void test() const{//const 成员函数 
    		_i++;//正确,mutable数据成员 
    		_staticVal++;//正确,static数据成员 
    		_val++;//错误 
    	} 
    }; 
    int base::_staticVal=0; 

     

    静态成员函数 

    静态成员函数没有什么太多好讲的。 

    1.
    静态成员函数的地址可用普通函数指针储存,而普通成员函数地址需要用类成员函数指针来储存。举例如下: 

    class base{ 
        static int func1(); 
        int func2(); 
    }; 
    
    int (*pf1)()=&base::func1;//普通的函数指针 
    int (base::*pf2)()=&base::func2;//成员函数指针 

    2. 静态成员函数不可以调用类的非静态成员 。因为静态成员函数不含 this指针  

    3.
    静态成员函数不可以同时声明为 virtualconstvolatile函数 。举例如下:  
    class base{ 
        virtual static void func1();//错误 
        static void func2() const;//错误 
        static void func3() volatile;//错误 
    }; 


    最后要说的一点是,静态成员是可以独立访问的,也就是说,无须创建任何对象实例就可以访问。

    展开全文
  • c与c++ static函数的区别

    千次阅读 2012-07-02 11:13:09
    c与c++ static函数的区别 c与c++ static函数的区别 static关键字是C, C++中都存在的关键字, 它主要有三种使用方式, 其中前两种只指在C语言中使用, 第三种在C++中使用(C,C++中具体细微...
  • ?const定义的常量在超出其作用域之后其空间会被释放而static定义的静态常量在函数执行后不会释放其存储空间 ? static表示的是静态的类的静态成员函数静态... 在C++static静态成员变量不能在类的内部初始化在类的内部
  • C++ static 静态数据和静态函数总结

    千次阅读 2013-11-16 09:40:13
    本文总结了所有关于C++ static修饰的数据和函数使用方法,作用和注意事项。 一 静态数据成员: public/protected/private访问规则不变 1.静态数据成员的声明: 静态数据成员实际上是类域中的全局变量。 谨记:...
  • Building c++ static library for iPhone

    千次阅读 2008-12-28 11:19:00
    It is a good idea to use c++ static library in a iPhone project, for xcode always need rebuild all files once a while ( Even if I modify only cpp file, I dont know why :( ).The way is simple but ther
  • C++static类成员,static类成员函数

    万次阅读 多人点赞 2017-03-20 14:33:14
    C++primer里面说过,static类成员不像普通的类数据成员,static类数据成员独立于一切类对象处在。static类数据成员是与类关联的,但不与该类定义的对象有任何关系。这句话什么意思?就是static不会想普通类数据...
  • ```C++ template class SetClass { public: const static int MAXSIZE; SetClass(void); SetClass(const T *a, int n); ~SetClass(void); bool IsInSet(const T &e) const; bool Insert(const T &e...
  • C++static_cast用法

    千次阅读 2016-08-21 22:42:48
    本文主要讲解了C++中几种强制类型转换中的static_cast的常用情况,并对其中容易出错的情况进行了实验,对相应结果进行分析。
  • C++ static关键词修饰类

    千次阅读 2018-07-18 09:24:36
    static若修饰以下时: ...C++中,static 在类内部的表现,用来实现族类对象间的数据共享。 在生成对象的时候,普通数据成员才有空间。而 static 成员在类声明的时候,就已经开辟了空间,在data ...
  • c与c++ static函数的区别(ZZ)

    千次阅读 2011-05-06 16:26:00
    c与c++ static函数的区别(ZZ)       转载自:http://blog.csdn.net/lipps/archive/2007/05/18/1615419.aspx<br />  c与c++ static函数的区别 static关键字是C, C++中都...
  • c++ static的使用方法

    千次阅读 2016-05-27 09:37:48
    static的使用方法 一.静态数据成员:    类体中的数据成员的声明前加上static关键字,该数据成员就成为了该类的静态数据成员。和其他数据成员一样,静态数据成员也遵守public protected private访问规则。同时...
  • Java - staticC++ static的区别

    千次阅读 2014-04-02 15:25:35
    java的staticc++static多数用法是相同,包括static method、static variable。其中static variable主要用于定义该类所有实例共用的一些数据(如值不变的状态变量等),主要目的是节省内存,因为不管new多少个...
  • C++static Vector 类型 初始化

    千次阅读 2016-11-01 16:28:40
    _init_static_Vector.h: private:static std::vector mStrings; static bool _init; static bool init();_init_static_Vector.cpp:std::vector _init_static_Vector::mStrings; bool A2dpProfile::_init = _init...
  • 全局数据区:static 数据, 全局变量, const常量 堆区:由程序员自己new出来的动态数据, 需要手动释放。若忘记释放,会造成内存泄漏,则程序结束时会由操作系统回收。 栈区:函数内部变量,由IDE自动分配,结束时...
  • paip.c++ static 变量的定义以及使用...

    千次阅读 2013-10-01 17:06:01
    paip.c++ static 变量的定义以及使用...  作者Attilax , EMAIL:1466519819@qq.com  来源:attilax的专栏 地址:http://blog.csdn.net/attilax c++ static 变量的定义以及使用跟JAVA,C#稍微不一样.. ...
  • C++ static 和const 的作用

    千次阅读 2018-02-08 10:29:08
    //联系人:石虎 QQ:1224614774 昵称:嗡嘛呢叭咪哄 /** 问题1:static和const的作用; 问题2:类里面static和const可以同时修饰成员函数吗 */一、static的作用:对变量:1.局部变量: 在局部变量之前加上关键字...
  • C++ static const int 成员变量

    千次阅读 2019-09-03 23:19:03
    1.static const int 成员变量 (测试代码) #include<iostream> using namespace std; class widget { friend void print_widget(); private: static const int a = 20; //测试static const int public: ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 536,996
精华内容 214,798
关键字:

c++static

c++ 订阅