精华内容
下载资源
问答
  • 类的常数据成员必须进行初始化,而且只能通过构造函数的成员初始化列表的方式来进行。列表中对成员的初始化顺序,与它们在列表中的顺序无关,而与它们在类中的声明顺序有关。包含常数据成员的类不能使用默认构造函数...

    类的常数据成员必须进行初始化,而且只能通过构造函数的成员初始化列表的方式来进行。列表中对成员的初始化顺序,与它们在列表中的顺序无关,而与它们在类中的声明顺序有关。包含常数据成员的类不能使用默认构造函数。在对象被创建以后,其常数据成员的 值不允许被修改。


    类的常成员函数声明格式如下:

    函数类型       成员函数名(参数列表)    const;

    修饰符 const要加在函数说明的尾部,并且作为函数类型的一部分,不能省略,如果长成员函数定义在类体外,则不论是类内声明还是类外定义,都不能省略关键字const。


    说明:

    1、const是函数类型的一部分,在声明和定义是都要就加上const;

    2、const成员函数即可引用const数据,也可引用非const数据,但都不能改变值。

    3、const成员函数不能访问非const成员函数。

    4、非const成员函数可引用const数据,也可引用非cosnt数据,但不能改变const数据。

    5、作为函数类型的一部分,const可以参与区分重载函数

    展开全文
  • 数据成员:静态数据成员是类的一部分,为类的所有实例共享(静态区); 非静态数据成员,类的每个实例都有一份拷贝(动态区)。静态数据成员的访问:静态数据成员是类的一部分,在产生任何实例之前已经存在,通过 类名...

    数据成员:

    静态数据成员是类的一部分,为类的所有实例共享(静态区);
    非静态数据成员,类的每个实例都有一份拷贝(动态区)。

    静态数据成员的访问:

    静态数据成员是类的一部分,在产生任何实例之前已经存在,通过
    类名::静态成员变量名 访问。

    函数成员(都在代码区):

    静态函数成员与非静态函数成员都为类所有,对象并不存在函数的拷贝。静态成员函数和非静态成员函数的根本区别在于非静态函数由对象名.或者对象指针->调用,调用时编译器会向函数传递this指针;静态成员函数则有类名::或者对象名.调用,编译器不向函数传递this指针,不识别对象个体,经常用来操作类的静态数据成员,要访问类的非静态成员可以通过对象来实现。

    内存角度分析:

    类的静态成员(数据成员和函数成员)为类本身所有,在类加载的时候就会分配内存,可以通过类名直接访问;非静态成员(数据成员和函数成员)属于类的实例所有,所以只有在创建类的实例的时候才会分配内存,并通过实例去访问。

    注意:类的静态数据成员是静态存储,它是静态生存周期,必须进行初始化。静态数据成员的初始化在类体外进行,前面不加static以免与一般静态变量或者对象混淆。

    静态成员函数访问非静态成员报错:

    类的静态成员在类加载的时候就已经分配内存,而此时类的非静态成员尚未分配内存,访问内存中不存在的东西自然会出错。

    #include 
    using namespace std; 
    
    class Test 
    { 
      public: 
        Test(int a){ A = a; ++B;} 
        static void smf(Test tt); 
      private: 
        int A; 
        static int B; 
    }; 
    
    void Test::smf(Test tt) 
    { 
      cout<<"tt.A:"<<tt.A<<endl;//静态成员函数中通过对象来引用非静态成员 
      cout << "Test::B : " << Test::B << endl; 
      cout << "tt.B : " << tt.B << endl; 
    } 
    
    int Test::B = 0;//静态数据成员初始化的格式<数据类型><类名>::<静态数据成员名>=<值> 
    
    int main() 
    { 
      Test t1(100); 
      Test t2(200); 
      Test::smf(t1); 
      Test::smf(t2);//静态成员函数调用时不用对象名 
    
      system("pause"); 
      return 0; 
    }

    展开全文
  • 1、引用AVCodecContext中对该数据成员的解释 /** * some codecs need / can use extradata like Huffman tables. * MJPEG: Huffman tables * rv10: additional flags * MPEG-4: global headers (they can be

    1、引用AVCodecContext中对该数据成员的解释

    /**
         * some codecs need / can use extradata like Huffman tables.
         * MJPEG: Huffman tables
         * rv10: additional flags
         * MPEG-4: global headers (they can be in the bitstream or here)
         * The allocated memory should be AV_INPUT_BUFFER_PADDING_SIZE bytes larger
         * than extradata_size to avoid problems if it is read with the bitstream reader.
         * The bytewise contents of extradata must not depend on the architecture or CPU endianness.
         * - encoding: Set/allocated/freed by libavcodec.
         * - decoding: Set/allocated/freed by user.
         */
        uint8_t *extradata;
        int extradata_size;

    可见它针对不同的情况有不同的格式,而比较常用的情况就是我们对视频流进行写入文件操作时(某些情况下,如通过NV12格式编码的视频流数据),或则解码视频文件时需要我们去设置。此时extradata作为一个global headers,主要保存SPS、PPS等信息,下面就针对此种情况进行说明。


    2、格式规定

    MPEG-4 Part 15 "Advanced Video Coding (AVC) file format" section 5.2.4.1 的规定如下:

    aligned(8) class AVCDecoderConfigurationRecord { 
       unsigned int(8) configurationVersion = 1; 
       unsigned int(8) AVCProfileIndication; 
       unsigned int(8) profile_compatibility; 
       unsigned int(8) AVCLevelIndication;  
       bit(6) reserved = ‘111111’b;
       unsigned int(2) lengthSizeMinusOne;  
       bit(3) reserved = ‘111’b;
       unsigned int(5) numOfSequenceParameterSets; 
       for (i=0; i< numOfSequenceParameterSets;  i++) { 
          unsigned int(16) sequenceParameterSetLength ; 
      bit(8*sequenceParameterSetLength) sequenceParameterSetNALUnit; 
     } 
       unsigned int(8) numOfPictureParameterSets; 
       for (i=0; i< numOfPictureParameterSets;  i++) { 
      unsigned int(16) pictureParameterSetLength; 
      bit(8*pictureParameterSetLength) pictureParameterSetNALUnit; 
     } 
    }


    引用一个MP4文件中包含sps、pps数据的数据段

    其中有一个sps块(e1 & 1F),长度为26字节(0x00 1a),后面就是这个序列参数集的真正内容;

    一个pps块(01  & FF),长度为4字节(0x04),后面就是这个图像参数集的真正类容

    如何提取提取数据参见:http://blog.csdn.net/a812073479/article/details/74716476


    3、extradata的设置

          (1)直接设置原始的PPS、SPS数据

                   数据格式如下(黄色部分为SPS数据、红色部分为PPS数据)


                   将这部分数直接送给extradata的前面即可,后面填充AV_INPUT_BUFFER_PADDING_SIZE 个字节的0数据

          (2)某些情况下需要按照文档中定义的那样来设置

                  参考链接:https://stackoverflow.com/questions/15263458/h-264-muxed-to-mp4-using-libavformat-not-playing-back

                                      https://devtalk.nvidia.com/default/topic/718718/-howto-h-264-mp4-container/?offset=1

    展开全文
  • **************************数据成员的初始化 *******************************************************************************************************************1、数据成员是否能在定义类的时候就初始化?...
    **************************C++中的static的用法********************************
    *******************************************************************************
    C++primer里面讲过:static成员它不像普通的数据成员,static数据成员独立于该类的任意对象而存在,每个static数据成员是与类关联的对象,并不与该类的对象相关联!这句话可能比较拗口,其实可以这么理解:每个static数据成员可以看成是类的一个对象,而不与该类定义的对象有任何关系!下面我们就来具体看看类中的static数据成员!
    一、static变量 修饰数据成员
    1、static变量 ( 修饰数据成员) 的例子: 
    #include<iostream>
    #include<string>
    using namespace std;
    
    class Person
    {
    private:
            string name;
            static int age;  //static数据成员age
    public:
            Person(const string &nm):name(nm){};
            void Print();
    };
    int Person::age = 20; //对static数据成员进行初始化
    
    void Person::Print(){
            cout<<name<<" is "<<age<<endl;
    }
    
    int main(int argc,char **argv)
    {
            Person person("tom");
            person.Print();
            Person person2("nike");
            person2.Print();
            person.Print();
            return 0;
    }
    
    解释一哈:
         对于非静态数据成员,每个类对象都有自己的拷贝。而静态数据成员被当作是类的成员。无论是这个类的对象被定义了多少个,静态数据成员在程序中也只有一份拷贝,由改类型的所有对象共享访问。也就是说,静态数据成员是该类的所有对象所共有的。对该类的多个对象来说,静态数据成员只分配一次内存,供所有对象共用。所以,静态数据成员的值对每个对象都是一样的,他的值可以更新。
    对C++中静态数据成员的了解:
        静态数据成员初始化格式:<数据类型><类名>::<静态数据成员名>=<值>
       存储:static数据成员是存储在程序的静态存储区,并不是在栈空间上的。(一般程序的由new产生的动态数据存放在堆区,函数内部的自动变量存放在栈区。自动变量一般会随着函数的退出而释放空间,静态数据(即使是函数内部的静态局部变量)也存放在全局数据区。全局数据区的数据并不会因为函数的退出而释放空间。
        初始化:在类中不能对static数据成员进行初始化,要初始化的话必须在类外进行定义! static数据成员不是通过类构造函数进行初始化的!如上面的代码所示:在类外定义int Persion::age = 20;这里前面就不加static 了。
        如何访问static数据成员:我们可以通过作用域操作符从类直接调用static数据成员;或者通过对象;或者通过引用;或者指向改类类型对象的指针间接调用(这种情况下static数据成员是public的访问权限,如果定义在private访问权限下是不行的)。
        注意:如果类中有多个static数据成员,static数据成员初始化的次序是按照static数据成员在类中的声明次序进行初始化的,初始化后,就可以使用static数据成员了。

        总结:在类中的static成员变量属于整个类所拥有,对类的所有对象只有一份拷贝。

    2、const static数据成员 的例子: 

    像上面说的,类的static成员,智能在类的定义体外进行初始化。const int 类型的static成员便可以在类定义体内部进行初始化。记住,一定只能是const int型的,换成const string ,double都不行的。

    #include<iostream>
    #include<string>
    using namespace std;
    class Person
    {
    private:
            string name;
            static const int age = 20;//在类的定义体内进行初始化
            static string address;
    public:
            Person(const string&nm):name(nm){}
            static string Address()
            {
                    return address;
            }
            void Print()
            {
                    cout<<name<<" is "<<age;
            }
    };
    string Person::address = "XiangGang"; //在类的定义体外进行初始化
    
    int main()
    {
            Person person("tom");
            person.Print();
            cout<<" and live in "<<person.Address();
            cout<<endl;
            return 0;
    }
    

    解释一哈:

        只有age才能在类定义体内进行初始化,address是不行的。

    3、****** 的例子: 

        static数据成员的类型可以是该成员所属的类的类型,非static数据成员被限定为其自生类的指针或引用。

    class Person
    {
    private:
            string name;
            static const int age = 20;//在类的定义体内进行初始化
            static string address;
            static Person person1;
            Person *person2;
            Person person3;
    public:
            Person(const string&nm):name(nm){}
            static string Address()
            {
                    return address;
            }
            void Print()
            {
                    cout<<name<<" is "<<age;
            }
    };
    

    解释一哈:

        如果没有定义person3,则能顺利通过编译,但是加上person3就不能通过编译了。


    二、static变量 修饰成员函数: 

    #include<iostream>
    using namespace std;
    class Myclass
    {
    public:
            Myclass(int a,int b,int c);
            static void GetSum();//声明静态成员函数
    private:
            int a,b,c;
            static int Sum;//声明静态数据成员
    };
    int Myclass::Sum = 0;//定义并初始化静态数据成员
    
    Myclass::Myclass(int a,int b,int c)
    {
            this->a = a;
            this->b = b;
            this->c = c;
            Sum += a+b+c;//非静态成员函数可以访问静态数据成员
    }
    
    void Myclass::GetSum() //静态成员函数的实现
    {
    //      cout<<a<<endl; //error a是非静态数据成员        
            cout<<"Sum = "<<Sum<<endl;
    }
    
    int main()
    {
            Myclass M(1,2,3);
            M.GetSum();
            Myclass N(4,5,6);
            N.GetSum();
            Myclass::GetSum();
    }
    

    解释一哈:

        非静态成员函数可以访问,静态数据成员与普通数据成员;静态成员函数只能访问,静态数据成员,不能访问非静态数据成员。

          说完了static成员后,我们再来看看static成员函数,static成员是类的组成部分并不是任何对象的组成部分,因此,static成员函数没有this指针。我们知道,一般而言,类中的成员函数具有一个附加的隐含实参,即指向该类对象的一个指针。这个隐含实参命名为this。因为static成员函数不是任何对象的组成部分,所以static成员函数就没有this形参了。由于成员函数声明为const说明该成员函数不会修改该成员函数所属的对象,所以static成员函数不能声明为const。为什么呢?因为static成员函数不是任何对象的组成部分。static成员函数可以直接访问所属类的static成员,但是不能直接使用非static成员函数!也不能访问static const 类型的成员!在上面的代码中static  string Address()函数中如果是return name或者是return age都不行! 

     注意:

         *出现在类体外的函数是不能指定关键字static的;

         *静态成员之间可以相互访问,  包括静态成员函数访问静态数据成员和访问静态成员函数;

          *非静态成员函数可以任意访问静态成员函数和静态数据成员;

          *静态成员函数不能访问非静态成员函数和非经验数据成员;

          *因为没有this指针的额外开销,因此静态成员函数与类的全局函数相比速度会有少许的增长;

          *调用静态成员函数,可以用成员访问操作符(.)(->)为一个类的对象或指向类对象的指针调用静态成员函数,也可以直接使用如下格式:
    <类名>::<静态成员函数名>(<参数表>)
    调用类的静态成员函数。

        总结:在类中的static成员函数属于整个类所拥有,这个函数不接受this指针,因而只能访问类的static成员变量。


    参考的网址:

       1》C++类中的static数据成员、static成员函数:https://www.cnblogs.com/yyxt/p/4802688.html

       2》C++中static的完全解析:https://blog.csdn.net/jsjwql/article/details/1788286

    展开全文
  • static数据成员与static成员函数

    千次阅读 2013-05-13 11:51:45
    定义:用static关键字声明的数据成员称为静态数据成员。 每个类只有一个存储单元,静态数据成员为该类的所有对象共有,不属于某个对象。静态数据成员的初始化必须在类以外进行定义性说明。 形式为:类型> 类名>:...
  • C++ --- 静态数据成员

    千次阅读 2018-07-31 23:35:09
    静态数据成员 多个同类的对象之间实现数据共享,但是不用全局变量,可以用静态数据结构成员。因为全局变量的值可以在各处随意的修改,很可能因为一处失误,导致整个程序失败。 #include &lt;iostream&gt;...
  • 对象成员

    千次阅读 2013-04-24 16:46:42
    对象成员包括成员函数和常数据成员。 1. 成员函数 使用const关键字声明的函数为成员函数,成员函数声明格式如下: 类型 函数名(参数表) const ; 对于对象成员需要注意以下几点: (1...
  • 类的静态成员函数和静态数据成员

    千次阅读 2015-10-10 21:31:27
    一、基本知识当将类的某个数据成员声明为static时,该静态数据成员只能被定义一次,而且要被同类的所有对象共享。各个对象都拥有类中每一个普通数据成员的副本,但静态数据成员只有一个实例存在,与定义了多少类对象...
  • 数据格式

    千次阅读 2017-04-09 13:45:31
    一、矢量数据格式 矢量数据(Vector Data)是用X、Y、Z坐标表示地图图形或地理实体位置的数据。 矢量数据一般通过记录坐标的方式来尽可能将地理实体的空间位置表现的准确无误。 常见的矢量数据有:点、线、面等格式...
  • C++ 类数据成员指针

    千次阅读 2014-03-02 15:02:05
    数据成员指针的定义格式:  类型 类名::*指针名 #include using namespace std; int s=0; class MyClass { public: MyClass(){n+=1;} void disp(){cout; cout;} int m, n; //声明数据成员 }; i
  • C++ Time类,有个private成员变量hours,然后类声明以后是不能直接 访问的 ,比如不能像这样 Time planning; planning.hours。不能这样使用是很明白的。但是却发现,在Time类的方法里面可以这样用, 很奇怪,这个...
  • C++指向类成员(数据、函数)的指针

    千次阅读 2017-08-20 18:37:20
    指向【类】的成员的指针包含两种: ★指向【类】的数据成员的指针 ★指向【类】的成员函数的指针 ...1、指向类的数据成员的指针1.1 定义+初始化的格式: 数据类型 类型:: *指针名 = &类型:: 非静态公有数据
  • 常用的数据格式汇总

    万次阅读 2018-05-16 19:59:02
    1、libsvm数据格式libsvm使用的训练数据和检验数据文件格式如下: [label] [index1]:[value1] [index2]:[value2] … [label] [index1]:[value1] [index2]:[value2] …label 目标值,就是说class(属于哪一类),...
  • 不允许 dllimport 静态数据成员

    万次阅读 2014-10-07 17:28:52
    不允许 dllimport 静态数据成员 View Code 当要使用一个类的时候必须要有其定义,有2种方式: 1、引用其头文件,即#include "xxx.h"。这是传统的方式。 2、使用导出类。 什么是‘导出类’,很...
  • 这里指向数据成员的指针和指向成员函数的指针与指向变量的指针和指向函数的指针进行对比来解释,比较好理解一些。指向变量的指针和指向函数的指针先举个例子:void func(int a, int b){ cout ; }int main() { int ...
  • OSG文件数据格式

    千次阅读 2019-04-02 10:35:02
    OSG场景数据格式,可以记录场景书结构的所有节点及其属性信息。 它属于文本文件类型,不需要专门的编辑器。 使用OSG自带的osgViewer.exe可以快速的浏览osg文件的内容;使用osgconv可以使文件在osg和其他数据格式中...
  • 1、在c++中,当把一个类的对象作为另一个新类的数据成员时,定义格式为: class X     {  类名1 成员名1;      类名2 成员名2;  其他成员;     } 2、如果一个类A的对象作为另一个类B的...
  • 指向类的数据成员和函数指针

    千次阅读 2011-09-09 16:18:41
    指向类成员的指针 在C++语言中,可以定义一个指针,使其指向类成员或成员函数,然后通过...à 指向数据成员的指针 在C++语言中,可以定义一个指针,使其指向类成员。当属性成员为静态和非静态时,指针的使用也有不同
  • 一个类的对象作为另一个类的数据成员。 &nbsp; &nbsp; &nbsp; &nbsp;一个类中的数据成员除了可以是int, char, float等这些基本的数据类型外,还可以是某一个类的一个对象。用子对象创建新类。 &...
  • (1)静态数据成员在每个类中只有一个拷贝,由所有该类的对象共同维护,从而实现同一个类的不同对象数据共享;一般数据成 员,是实例属性,每个对象拥有一个拷贝。 (2)静态数据成员只能通过类名和静态函数成员对...
  • C++ 对象和常成员函数

    千次阅读 2016-10-03 09:46:52
    对象:不能修改的对象。“只读”。使用const声明,声明时必须初始化。 格式: const 类名 对象名 (初始...只能访问数据成员而不能设置或修改数据成员。 返回类型 函数名 (形参表)const; const成员函数只能调用c
  • flink table api 自定义数据格式解析

    千次阅读 2019-02-21 16:47:32
    flink table api目前支持的数据格式(https://ci.apache.org/projects/flink/flink-docs-release-1.7/dev/table/tableApi.html )除基础数据格式外还支持pojo,但毕竟支持有限,我们希望通过固定的解析,就能直
  • 常成员函数

    千次阅读 2010-05-28 11:13:00
    常成员函数 使用const关键字进行说明的成员函数,称为常成员函数...常成员函数说明格式如下: () const; 其中,const是加在函数说明后面的类型修饰符,它是函数类型的一个组成部分,因此,在函数实现部分也要带const
  • C/C++ 数据格式

    千次阅读 2017-09-02 10:25:00
    C/C++ 数据格式化C/C++数据格式化输出的方式是设置格式化标志,格式化标志就是位掩码值,该位掩码值可以通过成员函数setf来设置,也可用unsetf来复位。标准流成员函数precision用来指定浮点值显示的小数位数。但是...
  • C++ 类 静态 数据成员 声明 初始化 使用
  • 静态成员数据 静态对象初始化

    千次阅读 2010-04-18 10:45:00
    1.静态成员数据的定义,与静态类型的变量的定义方式一样,要在成员数据的定义之前加关键字static。2.静态成员数据必须有确定的值,但由于在类的定义中不能对成员数据直接进行初始化,故必须在类定义的外部对静态...
  • 静态成员数据 静态对象初始化 .

    万次阅读 2012-09-15 22:13:45
    1.静态成员数据的定义,与静态类型的变量的定义方式一样,要在成员数据的定义之前加关键字static。 2.静态成员数据必须有确定的值,但由于在类的定义中不能对成员数据直接进行初始化,故必须在类定义的外部对静态...
  • 地理空间数据格式——GeoJSON

    万次阅读 2016-11-10 16:51:35
    GeoJSON地理空间信息数据交换格式

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 379,276
精华内容 151,710
关键字:

常数据成员格式