精华内容
下载资源
问答
  • static 定义成员函数报“Cannot declare member function ...to have static linkage“错误
    2021-12-02 20:34:24

    问题分析:
    出现这种情况通常.h文件中声明类的成员函数用static修饰。此时static的作用是让一个类只有一个static成员函数实例化。
    在.cpp文件中实现函数的时候,也加了static修饰符,此时static修饰符的作用是当前函数只能作用在当前的cpp文件。

    解决方法
    删除.cpp文件的static修饰符。或者在.h文件中实现。

    更多相关内容
  • error: cannot declare member functionstatic Eigen::Vector3d QuatPlane::logQuat(Eigen::Quaterniond)’ to have static linkage [-fpermissive] static Eigen::Vector3d QuatPlane::logQuat(Eigen::...
    • 静态函数和非静态函数的区别
      静态函数无需创建对象即可以直接使用类class::func的形式使用。
     error: cannot declare member function ‘static Eigen::Vector3d QuatPlane::logQuat(Eigen::Quaterniond)’ to have static linkage [-fpermissive]
     static Eigen::Vector3d QuatPlane::logQuat(Eigen::Quaterniond q) {
    

    编译出现报错,原因是类头文件cpp里面static关键字要消除

    注意:
    static的意义:一个作用域的范围(仅限本文件内).
    <1>.成员函数加static修饰的作用域是类域, 而在类外部加static不是表示静态函数,而是表示函数拥有本文件
    域,而类的域是小于文件域,强行把类域扩大到文件域,就会出错。

    -----https://blog.csdn.net/u010164190/article/details/108795795

    展开全文
  • 原因是static在.cc文件中的含义与类声明中的有所不同。这确实很愚蠢,但是关键字static具有三种不同的含义。在.cc文件中,static关键字表示该功能对于该特定文件之外的任何代码均不可见。 这意味着您不应该在.cc文件...

    “如果您在.cc文件中声明了一个静态方法。

    原因是static在.cc文件中的含义与类声明中的有所不同。这确实很愚蠢,但是关键字static具有三种不同的含义。在.cc文件中,static关键字表示该功能对于该特定文件之外的任何代码均不可见。

    这意味着您不应该在.cc文件中使用static来定义每个类的方法和变量。幸运的是,您不需要它。在C ++中,不允许使用与实例变量或实例方法同名的静态变量或静态方法。因此,如果您在类声明中将变量或方法声明为static,则在定义中不需要static关键字。编译器仍然知道变量/方法是类的一部分,而不是实例的一部分。”


    错误用法示例:

     在头文件FOO.h:

    class FOO
    {
       public:
         static int func();
    };

    在cc文件FOO.cc:

    static int FOO::func()
    {
       /* code */
    }

    正确用法示例1:

     在头文件FOO.h:

    class FOO
    {
       public:
         static int func();
    };

    在cc文件FOO.cc:

    int FOO::func()
    {
       /* code */
    }


    正确用法示例2:

     在头文件FOO.h:

    class FOO
    {
       public:
         static int func()
         {
           /* code */
         }
    };

    展开全文
  • //declare static member function static float average(); private: int num; int age; float score; //static data member,add the numbers of students static float sum; //static data member,add the counts...

           静态成员的提出是为了解决数据共享的问题。实现共享有许多方法,如:设置全局性的变量或对象是一种方法。但是,全局变量或对象是有局限性的。

    1.静态数据成员

    (1)作用1:节省内存

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

    (2)隐藏性和安全性

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

     

     

     

     

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

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

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

        <数据类型><类名>::<静态数据成员名>=<值>  //静态变量的初始化      类外定义——保证了定义只有一次

    3、初始化在类体外进行,而前面不加static,(这点需要注意)以免与一般静态变量或对象相混淆。初始化的地方就是定义的地方,一定要在全局作用域中定义,切记。

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

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

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

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

    8、类的对象可以使用静态成员函数和非静态成员函数。(类的对象可以调用静态或者非静态)

    #include <iostream>
    #include <string>
    using namespace std;
    class Point{
    public:
      void init(){}
      static double output(){return 1.2345;}
      
    private:
    
    };
    int main()
    {
      Point::output();
      Point pt;
      pt.init();
      cout << pt.output() << endl;
      cout << Point::output() << endl;
      return 0;
    }
    

    9、静态成员函数中不能使用非静态成员.如果使用如下,那么报错,因为静态数据成员没有this指针,它不属于任何对象。

    #include <string>
    #include <iostream>
    #include <stdio.h>
    using namespace std;
    class Point{
    public:
      void init() {}
      static void output(){printf("%d\n",m_x);}
      
    private:
      int m_x = 1;
    
    };
    
    int main()
    {
      Point pt;
        pt.output();
      return 0;
    }
    
    g++报错如下:
    error: invalid use of member ‘Point::m_x’ in static member function
       static void output(){printf("%d\n",m_x);}
    

    10.类的静态成员变量必须先初始化再使用,为了保证定义(或初始化)的唯一,和函数的实现放在一起。

    #include <string>
    #include <iostream>
    using namespace std;
    class Point{
    public:
      Point(){m_nPointCount ++;}
      ~Point(){m_nPointCount --;}
      static void output(){
        printf("%d\n",m_nPointCount);
      }
    private:
      static int m_nPointCount;
    
    };
    //int Point::m_nPointCount = 0;     //如果在这里用注释符号//屏蔽这句话,那么会报错
    
    int main()
    {
      Point pt;
      pt.output();
    
      return 0;
    }
    
    
    报错:
    undefined reference to `Point::m_nPointCount'
    
    

    11.在类的非静态成员函数中使用类的静态成员,反之则不能。

    #include <string>
    #include <iostream>
    using namespace std;
    
    class Point{
    public:
      void init(){output();}
      static void output(){cout << k << endl;}
      static int k ;
    };
    int Point::k = 123;
    int main()
    {
      Point pt;
      pt.init();
      pt.output();
    
      return 0;
    }
    

    12.不能使用类名访问非静态成员。(不能用作用域运算符访问非静态成员)

    #include <string>
    #include <iostream>
    using namespace std;
    class Point{
    public:
      void init(){}
      static void output(){}
    private:
    };
    
    int main()
    {
      Point::init();
      Point::output();
      return 0;
    }
    
    
    error: cannot call member function ‘void Point::init()’ without object
       Point::init();

    13.公共的静态数据成员可以在类外直接引用,也可以通过对象名引用,但私有的静态数据成员只能公用的成员函数引用。

    14.构造函数:初始化对象的非static数据成员,以及一些其他的工作;
    析构函数:释放对象使用的资源,并销毁对象的非static数据成员;

    15.由于其没有隐含的this指针,所以不能够直接存取其class object中的非静态成员数据。

    16.静态数据成员甚至在类没有任何对象的时候都可以访问,静态成员可以独立访问,无需依赖任何对象的建立。

    17.静态数据成员可以作为成员函数的默认形参,而普通数据成员则不可以

    
    #include <iostream>
    #include <string>
    using namespace std;
    class Test{
      static int a;
      int b;
      void fun_1(int i = a);       //right
      void fun_2(int i = b);       //这里报错,默认形参必须先先于类的对象而建立。所以要静态数据成 
                                   //员
    
    };
    
    int main()
    {
      return 0;
    }
    以上程序会报错。
    error: invalid use of non-static data member ‘Test::b’
    

    18.静态数据成员在const函数中可以修改,而普通的数据成员是不能修改的!

    #include <iostream>
    #include <string>
    using namespace std;
    class Test{
    public:
      Test():b(0){}
      //static member data
      static int a; //right
      int b;
      void test()const{
        a++; //right
        b++;//(wrong)const pointed you can't change data of the object who called it
      }
    };
    int Test::a = 1;
    int main()
    {
      Test t;
       return 0;
    }
    

    const修饰的时当前this指针所指向的对象是const,但是静态数据成员不属于任何类的对象,它被类的所有对象修改,所以this指针不修饰静态的数据成员,所以可以更改。

    19.关于静态成员函数

    (1)静态成员函数不能调用非静态成员函数,但是反过来是可以的

    (2)静态成员函数没有this指针,也就是说静态成员函数不能使用修饰符(也就是函数后面的const关键字)

    注意:静态成员函数中不能出现隐式的或者显式的this,即不能调用普通非static成员

    (3)静态成员函数的地址可用普通函数指针储存,而普通成员函数地址需要用 类成员函数指针来储存。

    #include<string>
    #include <iostream>
    using namespace std;
    class Student{
    public:
      //define the constructor
      Student(int n,int a,float s):num(n),age(a),score(s){}
      void total();
      //declare static member function
      static float average();
    private:
      int num;
      int age;
      float score;
      //static data member,add the numbers of students
      static float sum;
      //static data member,add the counts of students
      static int count;
    };
    
    //initialize the static data member,if you don't give it a value,then vill use the default value
    float Student::sum;
    int   Student::count;
    //define the non-static member function
    void Student::total(){
      //add the total score
      sum += score;
      //add the counts of students
      count ++;
    }
    //define the member function
    float Student::average(){
      return (sum/count);
    }
    int main()
    {
    
      Student stud[3]={
        //define object array and initialize
        Student(1001,18,70),
        Student(1002,19,78),
        Student(1003,20,98)
      };
      int n;
      std::cout << "please input the number of students:";
      std::cin >> n;
      //call 3 times of the function "total"
      for(int i = 0;i < n;i++)
         {
           stud[i].total();
         }
    
      //call the static member function
      std::cout<< "the average score of" << n << " students is " << Student::average() << std::endl;
      
      return 0;
    }
    
    

    20.类内初始化的静态const 成员只能是int型的.

    c++ primer 250页:
    我们可以为静态成员提供const整数类型的类内初始值。
    #include <iostream>
    #include <string>
    using namespace std;
    class Account{
     public:
      void calculate();          //calculate amount of one person
      static double rate();      //return interestRate
      static void rate(double);  //init interestRate
      static const int chineseRate =2 ;                //这个是对的
      static const double chineseRate3 = 1;            //这个是错的
      static constexpr double chineseRate2 = 0.2;
     private:
      string owner;
      double amount;
      static double interestRate;
      static double initRate();
      static const int int_type_variable = 1;      
    };
    

    结论:类内初始化的static const 初始化类型只能是int,不能是别的类型。

    21.类内的static const int(这里static const 也只能修饰int)类型如果程序中需要取地址,那么必须有类外定义,否则会出现错误如下(如果不在程序中使用地址,那么不需要在类外定义):

    class Account{
     public:
      void calculate();          //calculate amount of one person
      static double rate();      //return interestRate
      static void rate(double);  //init interestRate
      static const int chineseRate =2 ;
      static constexpr double chineseRate2 = 0.2;
     private:
      string owner;
      double amount;
      static double interestRate;
      static double initRate();
      static const int int_type_variable = 1;
    };
    
    那么会在这里报错:
    
    undefined reference to `Account::chineseRate'
    

     结论:即使一个常量静态对象在类内初始化了,通常情况下在类外定义也是一个一下该成员。

    22.如果要定义类内指定非int静态常量的初始值(初始值必须是constexpr),那么常量修饰符必须使用constexpr(非const,且初值必须是常量),如下:

    class Account{
     public:
      void calculate();          //calculate amount of one person
      static double rate();      //return interestRate
      static void rate(double);  //init interestRate
      static const int chineseRate =2 ;
      static const  double chineseRate2 = 0.2;   //这里报错,非int常量必须constexpr
     private:
      string owner;
      double amount;
      static double interestRate;
      static double initRate();
      static const int int_type_variable = 1;
    };
    
    error: ‘constexpr’ needed for in-class initialization of static data member ‘const double Account::chineseRate2’ of non-integral type [-fpermissive]
    

    注意:(1)g++编译器内static constexpr 和 constexpr static 功能一样 

    (2)若定义了常量表达式,那么可以用在任何需要常量表达式的地方,比如数组维度。但是如果使用static constexpr(或者static const int)的地址或者执行 const int &a =静态数据常量,必须在类外进行定义(类内指定初值),否则会报错,因为取地址必须先定义。

    结论:即使一个常量静态数据成员在类内部被初始化了,通常情况下也应该在类的外部定义一下该成员。

    23.虽然程序不能直接访问和修改私有static成员,但是可以定义成员函数更改和打印私有成员的值。

    如下:

    class Account{
     public:
      void calculate();          //calculate amount of one person
      static double rate();      //打印私有成员interestRate的值
      static void rate(double);  //更改私有成员interestRate的值
      static const int chineseRate =2 ;
      static constexpr  double chineseRate2 = 0.2;
     private:
      string owner;
      double amount;
      static double interestRate;
      static double initRate();
      static const int int_type_variable = 1;
    };
    
    double Account::Rate(){return interestRate;}
    void   Account::Rate(double newRate)
      {
       interestRate  = newRate;
      }

    24.静态成员的使用:可以通过类的对象、类的对象的引用、指针来访问非静态成员。

      Account t;
      Account *pt = &t;
      Account &rt = t; 
      cout << "rate 3" << endl;
      cout << t.rate() << endl;          //成员调用
      cout << pt -> rate() << endl;        //指针调用
      cout << rt.rate() << endl;          //引用调用

    25.成员函数(静态或者非静态的)不用通过作用域运算符就可以访问静态成员(interestRate就是静态成员).

    void Account::calculate()
    {
      amount += amount * (Account::interestRate);
    }

    结论:类的作用域内使用任何成员都不用加作用域运算符。(类作用域内可以用作用域运算符使用类的一切数据成员包括静态成员,所以成员函数往往有一些小的函数)

    26.类内可以定义所有类型的 static const + 类型(类型可以是内置类型,string类型,等,还可以是不完全类型Account)

    class Account{
     public:
     
      void calculate();          //calculate amount of one person
      static double rate();      //
      static void rate(double);  //init interestRate
      static const int chineseRate =2 ;
      static constexpr  double chineseRate2 = 0.2;
     private:
      string owner;
      double amount;
      static double interestRate;
      static double initRate();
      static const int int_type_variable = 1;
      static const char bkground;
      static const int  bk2;
      static const double bk3;
      static const string bk4;
      static const Account acc;
      
    };

    但是如果使用未定义的static const 就会报错,如下:

    r@r-Sys:~/now/7.6$ g++ main.cc function.cc -o 123
    /tmp/ccLrFZYt.o: In function `Account::print_static()':
    main.cc:(.text._ZN7Account12print_staticEv[_ZN7Account12print_staticEv]+0xe): undefined reference to `Account::bk2'
    main.cc:(.text._ZN7Account12print_staticEv[_ZN7Account12print_staticEv]+0x38): undefined reference to `Account::bk3'
    main.cc:(.text._ZN7Account12print_staticEv[_ZN7Account12print_staticEv]+0x69): undefined reference to `Account::bk4[abi:cxx11]'
    collect2: error: ld returned 1 exit status
    

    结论:可以定义static const + 类型(一切类型),但是只有int型可以给定初值,其它都无法给定初值,使用前没有初值必然报错,所以只能用constexpr代替(非int的时候)。

    27.static 类型(可以是static,static const或者static constexpr)可以作为函数的参数,非static类型不可以(提示:成员函数默认实参在申明的时候指定,申明时候不指定,都指定会报错,其它的不知道)

    void Account::calculate(double d = interestRate)
    {
      cout << "print the interestRate :: " << d <<  endl;
      amount += amount * (Account::interestRate);
    }

    28.静态类型数据成员必须在类外定义,而静态类型函数可以在类外或者类内定义,定义方式类似于普通成员函数。但是在类外一律不允许出现static语句,static语句只能出现在申明的时候。

    29.类内使用类外的static成员的时候,必须指明类的名字。

    30.定义类的static成员的时候,从类名开始,作用域就在类内了,这意味着,接下来你可以使用类的一切成员。(注意:例中initRate()是类的私有成员函数)

    double Account::interestRate = initRate();//从Account开始,作用域就在类内了,所以可以调用类的私有成员函数initRate()

    结论:类作用域可以使用类的一切成员。(前提是类定义完毕时候)

    31.类似于全局变量,静态成员定义在类外,一旦被定义,就存在于程序的整个生命周期中。

    32.为了确保静态成员只定义一次,把类的静态数据成员的定义和其它的非内联函数的定义放在同一个文件中。

    33.静态数据成员可以用于某些场景,而非静态成员不能的几个情况举例。

    (1)静态数据成员可以是不完全类型,非静态数据成员不能.

    class Bar{
    public:
    
    //...
    private:
    static Bar men1; //正确,静态成员可以是不完全类型
    Bar * mem2;      //正确,指针可以是不完全类型
    Bar mem3;        //错误,数据成员必须是完全类型     
    
    };

    (2)静态成员可以作为默认实参,普通成员不能。

    class Screen{
    public:
    //bkground 表示一个在类中稍后定义的静态成员
     Screen & clear(char = bkground);
    private:
     static const char bkground;
    };
    
    这里有一个疑问:const char bkground在这里没有初值,外面也不能给值,有个鸟用啊?????????????????????????????????????????
    c++ primer 271页源代码

    结论:非静态数据成员不能作为默认形参,因为它的值本身属于对象的一部分,这么做的结果是无法真正提供一个对象以便从中获取成员的的值,最终将会引发错误。

    34.静态类型成员的相关定义.

    (1)定义:静态成员是指申明语句中有关键字static的成员,静态成员不是任意单独对象的组成部分,而是由该类的全体对象所共享。

    (2)优点:作用域位于类的范围内,避免与其它的成员或者全局作用域的名字冲突;可以是私有成员,而全局对象不可以;通过阅读程序可以非常容易地看出静态成员与特定类的关联,使得程序非常容易懂。

    (3)静态成员和普通成员的区别:

    主要体现在普通成员与类的对象关联,是某个具体对象的组成部分;而静态成员不属于任意具体对象,它由该类的所有对象共享;还有一个细微的区别,静态成员可以作为默认实参,而普通成员不可以。

    35.

    //example.h
    class Example{
    static double rate;
    static const int vecSize = 20;
    static vector<double> vec;
    };
    
    //function.cc
    double Example::rate = 1.2;
    vector<double> Example::vec{3.14};
    
    //main.cc
    #include "example.h"
    double Example::rate;
    vector<double> Example::vec;
    
    注意:
    这里如果使用rate和vec的值,rate的使用是合法的,结果0;
    但是vec是不合法的,g++会提示溢出如下:
    Segmentation fault (core dumped)
    
    说明:c++ primer,说的272页习题7.58解释最后2行程序都是错的,但是g++编译器显示倒数第二个是可以使用的,值是0,但是倒数第一个确实是不能使用(如果不适用就可以通过编译,使用值则不能通过编译)。注意编译的时候main.cc 单独编译,如果和function.cc一起编译确实结果就错误了。

    13.练习(有待于进一步完成)

    再给一个利用类的静态成员变量和函数的例子以加深理解,这个例子建立一个学生类,每个学生类的对象将组成一个双向链表,用一个静态成员变量 记录这个双向链表的表头,一个静态成员函数输出这个双向链表。

    [cpp] view plaincopy

    1. #include <stdio.h>  
    2. #include <string.h>  
    3. const int MAX_NAME_SIZE = 30;    
    4.   
    5. class Student    
    6. {    
    7. public:    
    8.     Student(char *pszName);  
    9.     ~Student();  
    10. public:  
    11.     static void PrintfAllStudents();  
    12. private:    
    13.     char    m_name[MAX_NAME_SIZE];    
    14.     Student *next;  
    15.     Student *prev;  
    16.     static Student *m_head;  
    17. };    
    18.   
    19. Student::Student(char *pszName)  
    20. {    
    21.     strcpy(this->m_name, pszName);  
    22.   
    23.     //建立双向链表,新数据从链表头部插入。  
    24.     this->next = m_head;  
    25.     this->prev = NULL;  
    26.     if (m_head != NULL)  
    27.         m_head->prev = this;  
    28.     m_head = this;    
    29. }    
    30.   
    31. Student::~Student ()//析构过程就是节点的脱离过程    
    32. {    
    33.     if (this == m_head) //该节点就是头节点。  
    34.     {  
    35.         m_head = this->next;  
    36.     }  
    37.     else  
    38.     {  
    39.         this->prev->next = this->next;  
    40.         this->next->prev = this->prev;  
    41.     }  
    42. }    
    43.   
    44. void Student::PrintfAllStudents()  
    45. {  
    46.     for (Student *p = m_head; p != NULL; p = p->next)  
    47.         printf("%s\n", p->m_name);  
    48. }  
    49.   
    50. Student* Student::m_head = NULL;    
    51.   
    52. void main()    
    53. {     
    54.     Student studentA("AAA");  
    55.     Student studentB("BBB");  
    56.     Student studentC("CCC");  
    57.     Student studentD("DDD");  
    58.     Student student("MoreWindows");  
    59.     Student::PrintfAllStudents();  
    60. }  

     

    展开全文
  • //cannot change the function points to int (*fcnPtr)(int); //point to a function with one argument // pass reference of pointer void myfunction (int *&p){p == <somevalue>}; 3 ways to pass C++...
  • c++ 类里的static

    2019-03-03 22:34:18
    关于没有类的c语言的static的作用:https://blog.csdn.net/sinat_27382047/article/details/71698157 ...Cannot declare member function …to have static linkage&amp;amp;amp;amp;amp;amp;amp;qu
  • // function that takes a reference to an int and sets the given object to zero void reset(int &i) // i is just another name for the object passed to reset {  i = 0; // changes the value of ...
  • 【数据库】数据库笔记

    千次阅读 2022-02-17 14:00:24
    A very large, integrated collection of data Function ​ models real-world enterprise entities e.g. students and courses Relation e.g. electives Why use a DBMS data independence and efficient access ...
  • 如果里面是int,则生成数据类型T=int的函数 字符串相加就是两个字符出链接 C++primer - page 680 Templates are foundation for generic programming in C++ If the function body is the same, only the type of ...
  • 整理的C++面经(较全)

    千次阅读 2022-04-04 09:36:04
    目录 C++篇 1.... 关键字 5.1 extern 和 static 的区别,什么情况用前者什么情况用后者 1)extern外部变量:它属于变量声明,extern int a和int a的区别就是,前者告诉编译器,有一个int类型的变量a定义...
  • Void pointers cannot be dereferenced as any other pointer. Appropriate typecasting is necessary. 凭借其灵活性,空指针还带来了一些约束。 无效指针不能像其他任何指针一样被取消引用。 适当的类型转换是必要...
  • hhh

    千次阅读 2017-09-24 15:05:13
    0.3 The main function 0.4 Curly braces 0.5 Using the standard library for output 0.6 The return statement 0.7 A slightly deeper look 0.8 Details Chapter 1 Working with strings 1.1 Input ...
  • Chapter 14 - Static Member variables and Copy Constructors Do you know the difference between a static and a non-static member of a class? Do you understand the difference between a copy constructor,....
  • Chapter 2. Variables and Basic Types What is type ? Property that determine the ...Objects, references, functions including function template specializations, and expressions have this property C++
  • Ivan Baev, Bharathi Seshadri, Stefan Pejic VecClone Pass: Function Vectorization via LoopVectorizer - Matt Masten, Evgeniy Tyurin, Konstantina Mitropoulou ISL Memory Management Using Clang Static ...
  • C++ 使用小结

    2019-07-11 12:52:31
    - 静态成员函数和静态数据成员,定义时,不需要加static修饰符,否则会报错:"Cannot declare member function ...to have static linkage"; - public方法访问static成员;static方法只能访问static成员...
  • A comparison of C# vs. java

    2019-07-17 02:18:48
    Member Initialization at Definition and Static Constructors Boxing The Same But Different This section describes concepts and language features that differ either only in syntax or in ...
  •  member function func_get_dname return varchar2  );  /  2》建立对象类型体  create or replace type body emp_m_type is  member procdure proc_change_addr(newaddr varchar2)  is  begin  ...
  • C++ 2:短裤

    2019-05-08 17:04:35
    cannot be altered by the program during normal execution 定义 常 量、 常 引用 const int r = 50; const string r = "O,Fuck" const int& r = n; 常量 指针 const int* p = & n 不...
  • For templates, the compiler needs to have the code that defines a function template or class template member function to generate an instantiation. So, headers for templates should include definitions...
  • We decide to modify the Widget class to keep track of how many times each member function is called by reusing the existing Timer class. class Timer { public : explicit Timer ( int ...
  •  Templates are different: To generate an instantiation, the compiler needs to have the code that defines a function template or class template member function. As a result, unlike nontemplate code,...
  • Java课件笔记:sec1

    2019-01-03 20:04:03
    public static int average(int n1, int n2, int n3) {// version C System.out.println("Run version C"); return (n1+n2+n3)/3; } public static void main(String[] args) { System.out.println...
  • 添加成员member alter database add logfile member ‘d:\temp\aa2.log’ to group 4; 控制文件位置: 1.查看初始化参数 :init.ora 2 打开文件找到control_files:* 生成本地Tablespace create tablespace example...
  • vb.net教程

    2019-03-21 11:20:27
    功能 Function 子 Sub 运算符 Operator 获取 Get 组 Set AddHandler RemoveHandler 的RaiseEvent   ...
  • may declare an appropriate getResult() member function as part of its interface. The ConcreteBuilder object is not required to be supplied to the Director via a constructor, it could also be a ...
  • may declare an appropriate getResult() member function as part of its interface. The ConcreteBuilder object is not required to be supplied to the Director via a constructor, it could also be a ...
  • VB.NET 教程_01_基础语法

    万次阅读 多人点赞 2018-08-08 00:48:58
    功能 Function 子 Sub 运算符 Operator 获取 Get 组 Set AddHandler RemoveHandler 的RaiseEvent   ...
  • 12-17-2018学习-2.3&10.5

    2018-12-17 13:34:18
    The first member is equivalent to m.lower_bound(k) and second is equivalent to m.upper_bound(k). 它的 first 成员等价于 m.lower_bound(k)。而 second 成员则等价于 m.upper_bound(k) ...
  • Oracle对象的基本组件

    千次阅读 2007-03-15 15:23:00
    MAP MEMBER FUNCTION get_idno RETURN NUMBER IS BEGIN RETURN idno; END; MEMBER PROCEDURE display_details ( SELF IN OUT NOCOPY person_typ ) IS BEGIN -- use the PUT_LINE procedure of the DBMS...

空空如也

空空如也

1 2 3 4 5
收藏数 96
精华内容 38
关键字:

cannot declare member function 'staticint student

友情链接: H.S research.zip