精华内容
下载资源
问答
  • 面试题:下面哪个对类声明错误的? A、class MyClass extends MySuperClass1,MySuperClass2{} B、public class MyClass{} C、abstract class MyClass implements YourInterface1,YourInterface2{} D、private...

    题目:

    面试题:下面哪个对类的声明是错误的?

    A、class MyClass extends MySuperClass1,MySuperClass2{}
    
    B、public class MyClass{}
    
    C、abstract class MyClass implements YourInterface1,YourInterface2{}
    
    D、private class MyClass{}
    
    E、class MyClass extends MySuperClass implements YourInterface{}
    

    结果:A

    解释:

    A:类只支持单继承,所以A错误。

    B:public是类修饰符,class表示这是个类,MyClass是类名,B正确。

    C:abstract是抽象类的类修饰符,class表示这是个类,MyClass是类名,类支持多实现,并且前面的public可以写可以不写,如果写的话需要保证文件名和类名一致,C正确。

    D:内部类可以使用public、protected、默认修饰符、private修饰,所以D正确

    E:可访问控制符可以不写,类支持单继承多实现,所以E正确

    展开全文
  • C++ 类声明 前置声明范例

    千次阅读 2019-07-19 18:47:40
    在编写C++程序的时候,偶尔需要用到前置声明...这是必须的,因为A中用到了B,而B的声明出现在A的后面。如果没有B的前置说明,下面的程序将不同通过编译,编译器将会给出类似“缺少类型说明符”这样的出...

    转载自http://www.cnblogs.com/staring-hxs/p/3244251.html

    在编写C++程序的时候,偶尔需要用到前置声明(Forward declaration)。下面的程序中,带注释的那行就是类B的前置说明。这是必须的,因为类A中用到了类B,而类B的声明出现在类A的后面。如果没有类B的前置说明,下面的程序将不同通过编译,编译器将会给出类似“缺少类型说明符”这样的出错提示。

    代码一:
    
    // ForwardDeclaration.h
    #include <iostream>
    using namespace std;
    class B;             // 这是前置声明(Forward declaration)
    class A
    {
    private:
             B* b;
    public:
             A(B* b):b(b){}
    };
    
    class B
    {
    };
    
    // Main.cpp
    #include "ForwardDeclaration.h"
    int main(int argc, char** argv)
    {
             B* b = new B();
             A* a = new A(b);
             delete a;
             delete b;
             return 0;
    }

    上面程序可以顺利编译和运行(几乎没有做什么,也没有输出)。

    是不是有了前置说明就万事大吉了呢?我们看看下面的代码(带阴影部分的代码是新增加的):

    代码二:
    
    
    // ForwardDeclaration.h
    #include <iostream>
    using namespace std;
    class B;             // 这是前置声明(Forward declaration)
    class A
    {
    private:
             B* b;
    public:
             A(B* b):b(b){}
            void someMethod()
             {
                b->someMethod();                                                  // (1)
             }
    };
    
    class B
    {
    public:
          void someMethod()
           {
              cout << "something happened..." << endl;
           }
    };
    // Main.cpp
    #include "ForwardDeclaration.h"
    int main(int argc, char** argv)
    {
             B* b = new B();
             A* a = new A(b);
        a->someMethod();
        delete a;
        delete b;
        return 0;
    }

    一编译,发现代码(1)处出错。出错提示往往包括(不同的编译器给出的提示会有所不同):

    1. 使用了未定义的类型B;

    2. “->somemethod”的左边必须指向类/结构/联合/泛型类型

    原因:

    1. (1)处使用了类型B的定义,因为调用了类B中的一个成员函数。前置声明class B;仅仅声明了有一个B这样的类型,而并没有给出相关的定义,类B的相关定义,是在类A后面出现的,因此出现了编译错误;

    2. 代码一之所以能够通过编译,是因为其中仅仅用到B这个类型,并没有用到类B的定义。

    解决办法是什么?

    将类的声明和类的实现(即类的定义)分离。如下所示:

    // ForwardDeclaration.h   类的声明
    #include <iostream>
    using namespace std;
    class B;             // 这是前置声明(Forward declaration)
    class A
    {
    private:
             B* b;
    public:
            A(B* b);
    void someMethod();
    };
    
    class B
    {
    public:
    void someMethod();
    };
    // ForwardDeclaration.cpp        类的实现
    #include "ForwardDeclaration.h"
    A::A(B* b):b(b)
    {
    
    }
    
    void A::someMethod()
    {
        b->someMethod();
    }
    
    void B::someMethod()
    {
        cout << "something happened..." << endl;
    }
    // Main.cpp
    #include "ForwardDeclaration.h"
    int main(int argc, char** argv)
    {
             B* b = new B();
             A* a = new A(b);
             a->someMethod();
         delete a;
             delete b;
         return 0;
    }

    结论:

    前置声明只能作为指针或引用,不能定义类的对象,自然也就不能调用对象中的方法了。

    而且需要注意,如果将类A的成员变量B* b;改写成B& b;的话,必须要将b在A类的构造函数中,采用初始化列表的方式初始化,否则也会出错。关于这点

    展开全文
  • 下列的符号常量定义中,错误的定义是() A const M = 10 B const int M = 10 C const char ch D const bool mark = true 我觉得A和C都啊!一个没有声明一个没有初始化!
  • 作者:朱金灿http://blog.csdn.net/clever101 的前置声明(forward declaration)和包含头文件(#include)的区别常常会迷惑我们,特别是涉及两个相互包含的时候。因此我们有必要搞清楚二者的区别以及二者的...

     

    作者:朱金灿

    http://blog.csdn.net/clever101

     

        类的前置声明(forward declaration)和包含头文件(#include)的区别常常会迷惑我们,特别是涉及两个类相互包含的时候。因此我们有必要搞清楚二者的区别以及二者的适用场合。

     

    首先我们需要问一个问题是:为什么两个类不能互相包含头文件?所谓互相包含头文件,我举一个例子:我实现了两个类:图层类CLayer和符号类CSymbol,它们的大致关系是图层里包含有符号,符号里定义一个相关图层指针,具体请参考如下代码(注:以下代码仅供说明问题,不作为类设计参考,所以不适宜以此讨论类的设计,编译环境为Microsoft Visual C++ 2005,Windows XP + sp2,以下同):

     

          

     

         

       

    现在开始编译,编译出错,出错信息如下:

    1>正在编译...

    1>TestUnix.cpp

    1>f:/mytest/mytest/src/testunix/symbol.h(14) : error C2143: 语法错误: 缺少“;(在“*”的前面)

    1>f:/mytest/mytest/src/testunix/symbol.h(14) : error C4430: 缺少类型说明符- 假定为int。注意: C++ 不支持默认int

    1>f:/mytest/mytest/src/testunix/symbol.h(14) : error C4430: 缺少类型说明符- 假定为int。注意: C++ 不支持默认int

    1>Layer.cpp

    1>f:/mytest/mytest/src/testunix/symbol.h(14) : error C2143: 语法错误: 缺少“;(在“*”的前面)

    1>f:/mytest/mytest/src/testunix/symbol.h(14) : error C4430: 缺少类型说明符- 假定为int。注意: C++ 不支持默认int

    1>f:/mytest/mytest/src/testunix/symbol.h(14) : error C4430: 缺少类型说明符- 假定为int。注意: C++ 不支持默认int

    1>Symbol.cpp

    1>f:/mytest/mytest/src/testunix/layer.h(18) : error C2143: 语法错误: 缺少“;(在“*”的前面)

    1>f:/mytest/mytest/src/testunix/layer.h(18) : error C4430: 缺少类型说明符- 假定为int。注意: C++ 不支持默认int

    1>f:/mytest/mytest/src/testunix/layer.h(18) : error C4430: 缺少类型说明符- 假定为int。注意: C++ 不支持默认int

     

        现在让我们分析一下编译出错信息(我发现分析编译信息对加深程序的编译过程的理解非常有好处)。首先我们明确:编译器在编译文件时,遇到#include   "x.h"时,就打开x.h文件进行编译,这相当于把x.h文件的内容放在#include   "x.h"处。编译信息告诉我们:它是先编译TestUnix.cpp文件的,那么接着它应该编译stdafx.h接着是Layer.h如果编译Layer.h那么会编译Symbol.h但是编译Symbol.h又应该编译Layer.h啊,这岂不是陷入一个死循环? 呵呵,如果没有预编译指令,是会这样的,实际上在编译Symbol.h再去编译Layer.hLayer.h头上的那个#pragma once就会告诉编译器:老兄,这个你已经编译过了,就不要再浪费力气编译了!那么编译器得到这个信息就会不再编译Layer.h而转回到编译Symbol.h的余下内容。当编译到CLayer *m_pRelLayer;这一行编译器就会迷惑了:CLayer是什么东西呢?我怎么没见过呢?那么它就得给出一条出错信息,告诉你CLayer没经定义就用了呢?TestUnix.cpp#include "Layer.h"这句算是宣告编译结束(呵呵,简单一句弯弯绕绕不断),下面轮到#include "Symbol.h",由于预编译指令的阻挡,Symbol.h实际上没有得到编译,接着再去编译TestUnix.cpp的余下内容。

     

         当然上面仅仅是我的一些推论,还没得到完全证实,不过我们可以稍微测试一下,假如在TestUnix.cpp#include "Layer.h"#include "Symbol.h"互换一下位置,那么会不会先提示CSymbol类没有定义呢?实际上是这样的。当然这个也不能完全证实我的推论。

     

        照这样看,两个类的互相包含头文件肯定出错,那么如何解决这种情况呢?一种办法是在A类中包含B类的头文件,在B类中前置盛明A类,不过注意的是B类使用A类变量必须通过指针来进行,具体见拙文:类互相包含的办法。为何不能前置声明只能通过指针来使用?通过分析这个实际上我们可以得出前置声明和包含头文件的区别。我们把CLayer类的代码改动一下,再看下面的代码:

        

     

       

    然后编译,出现一个编译警告:>f:/mytest/mytest/src/testunix/layer.cpp(16) : warning C4150: 删除指向不完整“CSymbol”类型的指针;没有调用析构函数

    1>                            f:/mytest/mytest/src/testunix/layer.h(9) : 参见“CSymbol”的声明

     

           看到这个警告,我想你一定悟到了什么。下面我说说我的结论:类的前置声明和包含头文件的区别在于类的前置声明是告诉编译器有这种类型,但是它没有告诉编译器这种类型的大小、成员函数和数据成员,而包含头文件则是完全告诉了编译器这种类型到底是怎样的(包括大小和成员)。这下我们也明白了为何前置声明只能使用指针来进行,因为指针大小在编译器是确定的。上面正因为前置声明不能提供析构函数信息,所以编译器提醒我们:CSymbol”类型的指针没有调用析构函数。如何解决这个问题呢?在Layer.cpp加上#include "Symbol.h"就可以消除这个警告。

     

     

     

    展开全文
  • 一、类声明 //类是一种用户自定义类型,声明形式: class 类名称 {  public:  公有成员(外部接口) ...在关键字public后面声明,它们是类与外部的接口,任何外部函数都可以访问公有类型数据和函数。

    一、类声明

    //类是一种用户自定义类型,声明形式:
    class 类名称
    {
       public:
                 公有成员(外部接口)
       private:
                 私有成员
       protected:
                 保护成员
    };

    在关键字public后面声明,它们是类与外部的接口,任何外部函数都可以访问公有类型数据和函数。
    在关键字private后面声明,只允许本类中的函数访问,而类外部的任何函数都不能访问。
    在关键字protected后面声明,与private类似,其差别表现在继承与派生时对派生类的影响不同。

     C++ Code 
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    class Clock
    {
    public:
         void Display();
         void Init( int hour,  int minute,  int second);

    private:
         int hour_;
         int minute_;
         int second_;
    };


    假设定义了一个Clock 类,因为成员是private的,那么 Clock ck;  ck.hour_ = 12; 是错误的,对此定义一个public 的void SetHour(int hour) 来设置hour_ 的值。


    二、内联成员函数、成员函数的重载及其缺省参数

    这里有内联函数的概念。成员函数也可以是内联的,若在类内部实现,inline 关键字可加可不加;在类外部实现,需加inline,

    如 inline void Clock::SetHour(int hour) { } 。实际上即使加了inline也不一定宏展开,比如遇到switch,for 语句的时候就往往不会。

    此外,成员函数也像一般函数那样可以重载,也可以有缺省参数,参考这里


    三、类与结构体

    class与struct的区别:在未指定访问权限时,class默认的是私有的,struct默认是公有的,

    struct Test
    {
        int X;//公有的
         ...
    };

    此外,Test 可以独立作为一个tag,而不像C语言那样需要 struct Test 作为一个类型。


    四、隐含的 this 指针

    成员函数有一个隐含的附加形参,即指向该对象的指针,这个隐含的形参叫做this指针(编译器自动传递)

    使用this指针保证了每个对象可以拥有不同数值的数据成员,但处理这些成员的代码可以被所有对象共享

    成员函数是只读的代码,由所有对象共享,并不占对象的存储空间,因为this指针指向当前对象,所以成员函数可以区分它所作用的对象是哪一个。

    (哪个对象调用了this所在的函数,this就代表哪个对象)


    再来看一道经典的题目:

     C++ Code 
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    class A
    {
    public:
         int m;
         void print()
        {
            cout <<  "A" << endl;
        }
    };

    A *pa =  0;
    pa->print();

    可以理解为如下的C代码:

     C++ Code 
    1
    2
    3
    4
    5
    6
    void print(A * this)
    {
        cout <<  "A" << endl;
    }
    A *pa =  0;
    print_A(pa);

    相当于成员函数传递的this指针为0,那调用会出错吗? 肯定是正确输出"A" 的,因为this为0 表示没有对某个对象进行操作,而print里面确实没有对某

    个对象成员进行操作,所以是可以运行的。


    五、类作用域、前向声明

    (1)、每个类都定义了自己的作用域称为类作用域,类作用域中说明的标识符只在类中可见。除了类作用域,还有块作用域、文件作用域、函数原型作用域、函数作用域,举个例子:

     C++ Code 
    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
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    #include <iostream>
    using  namespace std;

    class Test
    {
    public:
         int num_;
    };

    //num_ = 20;        Error,num_的作用域在类内部
    int num_ =  20;       // num_的作用域是文件作用域,与类中的num_是不同的作用域

    int add( int a,  int b);   // a, b两个标识符的作用域为函数原型作用域

    int main( void)
    {
         int num_ =  30;       // num_为块作域
        {
             int num_ =  100// num_为块作域
        }

        cout << num_ << endl;
        cout <<::num_ << endl;
         return  0;
    }

    int add( int a,  int b)    // 形参a与b也算是块作用域
    {
         return a + b;
    }

    int test()
    {
    LABEL1:  //函数作用域
        cout <<  "label1" << endl;
         goto LABEL3;
    LABEL2:
        cout <<  "label2" << endl;
         goto LABEL1;
    LABEL3:
        cout <<  "label3" << endl;
         goto LABEL2;
    }

    (2)、C++中类必须先定义,才能够实例化。两个类需要相互引用头文件形成一个“环形”引用时会出错。这时候需要用到前向声明,前向声明的类不能实例,但可以定义指针或引用。

     C++ Code 
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    #ifndef _B_H_
    #define _B_H_

    class A;

    class B
    {
    public:
        B( void);
        ~B( void);

         void fun(A &a)
        {

        }

        A *a_;       // 前向声明的类不能实例化对象
    };

    #endif  // _B_H_

     C++ Code 
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    #ifndef _A_H_
    #define _A_H_

    #include  "B.h"
    class A
    {
    public:
        A( void);
        ~A( void);

        B b_;
    };

    #endif  // _A_H_

    六、嵌套类、局部类

    (1)、嵌套类

    外围类需要使用嵌套类对象作为底层实现,并且该嵌套类只用于外围类的实现,且同时可以对用户隐藏该底层实现。

    从作用域的角度看,嵌套类被隐藏在外围类之中,该类名只能在外围类中使用。如果在外围类之外的作用域使用该类名时,需要加名字限定。

    嵌套类中的成员函数可以在它的类体外定义。

    嵌套类的成员函数对外围类的私有成员没有访问权,反之亦然。

    嵌套类仅仅只是语法上的嵌入

    (2)、局部类

    类也可以定义在函数体内,这样的类被称为局部类(local class)。局部类只在定义它的局部域内可见。

    局部类的成员函数必须被定义在类体中。

    局部类中不能有静态成员,关于类中的静态成员和静态成员函数以后再谈。

     C++ Code 
    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
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    #include <iostream>
    using  namespace std;

    class Outer
    {
    public:
         class Inner
        {
         public:
             void Fun();
             //{
             //  cout<<"Inner::Fun ..."<<endl;
             //}
        };
    public:
        Inner obj_;
         void Fun()
        {
            cout <<  "Outer::Fun ..." << endl;
            obj_.Fun();
        }
    };

    void Outer::Inner::Fun()
    {
        cout <<  "Inner::Fun ..." << endl;
    }

    void Fun()
    {
         class LocalClass
        {
         public:
             int num_;
             void Init( int num)
            {
                num_ = num;
            }
             void Display()
            {
                cout <<  "num=" << num_ << endl;
            }

             //static int num2_; // 局部类内部不能定义静态成员
        };

        LocalClass lc;
        lc.Init( 10);
        lc.Display();
    }

    int main( void)
    {
        Outer o;
        o.Fun();

        Outer::Inner i;
        i.Fun();

        Fun();
         //LocalClass lc;        Error,局部类只能在定义它的函数体中使用
         return  0;
    }


    七、PIMPL 技法


    来看下面的示例:

     C++ Code 
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    // file y.h
    #include  "x.h"
    class Y
    {
         void Fun();
        X x_;

    };
    // file y.cpp
    #include "y.h"
    void Y::Fun
    {
         return x_.Fun();
    }
    // file main.cpp
    #include “y.h”
    int main( void)
    {
        Y y;
        y.Fun();
    }

    上面程序存在的问题是:

    1、引入更多的头文件,降低编译速度

    2、在编译期如果X的大小改变了,y.cpp 和 main.cpp 都得重新编译;在运行期,如果X有子类,也不能使用多态虚函数。

    3、假设y.cpp 编译成动态库给main.cpp 使用,当X的大小变化,动态库需要重新编译,此时main.cpp 因为有定义对象y ,故也需要

    重新编译。


    下面介绍一种PIMPL 技法,有人也把它当作一种设计模式:


    PIMPL(private implementation或pointer to implementation)也称为handle/body idiom

    PIMPL背后的思想是把客户与所有关于类的私有部分的知识隔离开。避免其它类知道其内部结构

    降低编译依赖、提高重编译速度

    接口和实现分离

    降低模块的耦合度

    编译期

    运行期

    提高了接口的稳定程度

    对于库的使用,方法不用改变

    对于库的编译,动态库的变更,客户程序不用重新编译


    修改后的程序:

     C++ Code 
    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
    28
    // file y.h
    class X;
    class Y
    {
        Y();
        ~Y();
         void Fun();
        X *px_;
    };
    // file y.cpp
    #include  "x.h"
    Y::Y() : px_(  new X ) {}
    Y::~Y()
    {
         delete px_;
        px_ =  0;
    }
    void Y::Fun()
    {
         return px_->Fun();
    }
    //  file main.cpp
    #include "y.h"
    int main( void)
    {
        Y y;
        y.Fun();
    }

    即Y 内部成员是X* 指针,在32位系统上,指针大小固定为4个字节,即使X大小改变,也不影响Y。如果X 有子类,通过基类指针px_ 

    还可以实现虚函数多态。


    参考:

    C++ primer 第四版
    Effective C++ 3rd
    C++编程规范


    展开全文
  • 错误C2027:使用了未定义类型、两个之间相互引用成员、向前声明错误C2027:使用了未定义类型向前声明单独编译两个之间相互引用成员通过单独编译和向前声明方法实现两个之间相互引用成员 错误C2027:使用了未定义...
  • C++里面vector声明错误:“expected parameter declarator

    千次阅读 多人点赞 2020-08-04 20:58:35
    发现这样的声明: struct TrieNode{ char data; bool isEnd = false; vector<TrieNode*> children(26);//想申请大小为26的数组 TrieNode(char data) : data(data){}; }; 会报错:expected parameter ...
  • Java之路:声明与定义

    万次阅读 多人点赞 2018-12-03 21:01:15
    一、声明 在使用之前,必须先声明它,然后才可以声明变量,并创建对象。 类声明的语法如下: [标识符] class 名称 { //的成员变量 //的方法 } 在上面的语法格式中,[标识符] 可以是public、private...
  • 下面重载乘法运算符的函数原型声明中正确的是: 正确答案: A B D 你的答案: D (错误) MyClass operator *(double ,MyClass); MyClass operator *(MyClass ,MyClass); MyClass operator *...
  • Python的变量和对象变量声明解析

    千次阅读 2018-02-14 23:43:57
    只要是声明在类的语句块中,且没有”self.”前缀的变量都是类变量,且类变量是被所有对象共享的。  注意加粗部分,如果声明在类的方法的语句块中,那么就是局部变量了!比如下面这个例子: 复制代码 ...
  • 错误: 从内部中访问本 地变量vvv; 需要被声明为最终类型 从github 下载了源码, 进行编译, 出现了下面错误 E:\downloads\ff\elasticsearch-master\elasticsearch-master>GRADLE :buildSrc:...
  • Qt中声明变量就出现未知的错误 下面是其中几种现象,都是建立在程序本来运行无误的基础上 1.有时在private中声明指针,程序编译通过,但不运行,无反应。换到private中声明 可能就能正确运行 2.有时public中声明常量...
  • 主要是:.xaml 文件中声明与.cs文件中的不一致导致。 如:下面是先列出会报错的情况。 BlankPage.xaml XAML x:Class="newGroupTest.BlankPage" xmlns:common="using:newGroupTest.Common" ......> ...
  • [C++]模板声明与实现分离问题

    千次阅读 2017-06-01 16:52:55
    做法:模板bag的声明与实现分离,也就是.cpp和.h文件分离 此时,编译失败。 将.cpp和.h取消(亦即取消声明与实现的分离) 此时,编译成功,运行正常。 马上查找资料,收集整理如下: C++ 中的模板类声明...
  • namespace命名空间成员声明

    千次阅读 2013-05-21 01:08:14
    namespace命名空间成员声明   这其实是QT空项目的架构!! [user:test] ls class.h main.cpp pub.cpp pub.h   [user:test] cat class.h /// @file class.h /// @brief /// @author EastonWoo ///...
  • 在构造自己的时,有可能会碰到两个之间的相互引用问题,例如:定义了AB,A中使用了B定义的类型,B中也使用了A定义的类型 class A { int i; B b; } class B { int i; A* a; } ...
  • 关于前向声明,嵌套,局部的使用。
  • 下面关于Java接口的说法错误的是() A、一个Java接口是一些方法特征的集合,但没有方法的实现 B、Java接口中定义的方法在不同的地方被实现,可以具有完全不同的行为 C、Java接口中可以声明私有成员 D、Java接口不能...
  • 错误消息 在函数“function”中引用了无法解析的外部符号“symbol” 在 function 中找到了未定义的外部符号 (symbol)。若要解决此错误,请提供符号定义或移除引用它的代码。一般报错如下:error LNK2001: ...
  • QT学习之路-C++的前置声明

    千次阅读 2015-09-14 15:08:49
    这次谈一谈我C++的前置声明的理解吧。 转自(http://qimo601.iteye.com/blog/1406992)刚开始学习c++的人都会遇到这样的问题: 定义一个 class A,这个里面使用了B的对象b,然后定义了一个B
  • 标题:一个在另一个中以集合形式声明为属性时应该注意的问题,先解释一下,看下面的代码吧 [Serializable] public class MO_T_sj_quest { public List AnswerList { get; set; } public List IDList { ...
  • 关于C语言隐式函数声明的基本问题,请参见我的博文万恶之源:C语言中的隐式函数声明下面是最近遇到的一个实例之一。 client_sock = accept(server_sock, (struct sockaddr*)&client_name, &client_name_len); ...
  • 类声明: class dog; //声明类定义: class dog{ //的定义}; 当用实例化一个的对象时,编译器会根据的定义来分配相应的存储空间 。也就是说,在创建对象前,一定要有完整的定义,这样编译器才能正确...
  • C++ 模板定义与声明

    万次阅读 2009-02-07 22:44:00
    声明和使用模板: 如果在模板外定义成员函数,应写成模板形式: template函数类型 模板名∷成员函数名(函数形参表列) {…}测试的模板,如下://Compare.h#ifndef _COMPARE_H#define _COMPARE_Htemplate ...
  • 声明包名时package开头的p报错(字母p下面有红线)。 错误发生原因: 重新引入某些包和之后就会出现这种情况。 解决方式: 鼠标悬浮在p下面的红线上,点击出现的提示,在build path里面重新配置jdk版本(注意...
  • 【0】README0.1) 本文描述+源代码均 转自 core java volume 1, 旨在理解 java异常——异常分类+声明已检查异常+如何抛出异常+自定义异常 的相关知识; 0.2)异常处理的任务: 就是将控制权从错误产生的地方转移...
  • 模板中的友元声明

    千次阅读 2012-03-08 09:32:45
    template class TreeNode { public : ...... template void SwapLR (TreeNode * t);... 模板中的友元声明还是有点讲究的。  最初的代码如下所示: template class TreeNode { public : ......
  • C++在命名空间中声明类和成员函数

    千次阅读 2018-06-24 15:47:22
    首先关于前置声明,有以下几点要注意:在b.h头文件中引入a时,有两种方式,前置声明和 #include “a.h”,建议使用前置声明,当a.h的私有成员改变时,b.h不需要重新编译。所以能用前置声明代替#include 的时候,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 596,071
精华内容 238,428
关键字:

下面哪个对类的声明是错误的