精华内容
下载资源
问答
  • 声明对象定义

    千次阅读 2018-01-26 20:33:08
    声明类类型,再用它去定义若干个同类型的对象。类是对象的模板。 类是抽象的,不占用内存。对象是具体的,占用内存。 2.声明类类型的方法跟声明结构体类型相似。格式如下: class 类型名 //类头 {private:

    1.对象的类型称为类,类代表一批对象的共性和特征。先声明类类型,再用它去定义若干个同类型的对象。类是对象的模板。

    类是抽象的,不占用内存。对象是具体的,占用内存。

    2.声明类类型的方法跟声明结构体类型相似。格式如下:

    class 类型名                              //类头

    {private:                                   //类体,内容是类的成员表,包括数据和函数

    私有的数据和成员函数;

    public:

    公用的数据和成员函数;

    };                                           //分号结束

    注意:

    1)一般是把数据隐蔽起来,而把成员函数作为对外界的接口;

    2)被声明为私有的成员,只能被本类中的成员函数引用,类外不能调用(友元类除外);公用的成员,外界可以调用

    3)除了private和public外,还有一种成员访问限定符,protected,称为受保护的成员,它不能被类外访问,和私有成员类似,但可以被派生类的成员函数访问。

    4)不指定为private或public系统默认为private

    5)通常先写public部分,再写private部分

    6)为了用户方便,c++编译系统往往向用户提供类库,内装常用的基本类,也可以把自己常用的类放在一个专门的类库中,需要时直接调用。

    3.定义对象的方法:

    1)先声明类类型,再定义对象  格式:类名 对象名

    2)声明类的同时定义对象

    3)不出现类名,直接定义对象(不提倡)

    class{  

    private:

    public:

    }stud1,stud2;

    4.类中不包含成员函数,相当于结构体

    5.一般的做法是把需要被外界调用的函数指定为public,指定为private的函数称为工具函数,它是被本类的成员函数调用的,支持其他函数的操作

    6.在类外定义成员函数

    可以在类体内进行函数声明,把定义放在类体外。(函数较长时推荐使用)

    注意:成员函数在类外定义的格式为    类名::函数名()

    “::”是作用域限定符

    函数名前面啥都没有的,是全局函数。

    7.内置inline成员函数

    当成员函数在类体中定义且不包含循环等复杂结构时,系统自动将其作为内置函数处理(效率高)inline 可省略

    否则不能省略

    8.成员函数的存储方式:

    1)同一类的不同对象的数据成员的值一般不同,但函数代码是相同的,调用不同对象的函数,调用的代码相同,但执行的结果一般不同,因为不同对象的函数调用的是本对象中的成员

    2)一个对象所占空间的大小只取决于数据成员,与成员函数无关

    3)this指针:当调用对象stud1的成员函数时,this指针就指向stud1,成员函数访问的就是stud1的成员

    9.对象成员的引用有三种方法

    1)对象名和成员运算符  stud1.num;

    2)指向对象的指针

    3)对象的引用

    注意:

    1)在一个类中至少要有一个公用的成员函数,否则就无法对对象进行任何操作;

    2)类外只能引用对象的公用数据成员,调用公用函数

    3)指针代码示例:

    Time t,*p;               //定义对象和指针

    p=&t;                     //p指向对象t

    cout<<p->hour;    //输出t的成员hour,等价于(*p).hour和t.hour

    4)引用代码示例:

    Time t1;

    Time &t2=t1;   //定义Time类引用,使之初始化为t1;

    cout<<t2.hour;


    展开全文
  • C++声明对象定义

    千次阅读 2015-05-15 09:49:49
    每一个实体都是对象。有一些对象是具有相同的结构和...正如同结构体类型和结构体变量的关系一样,需要先声明一个结构体类型,然后用它去定义结构体变量。同一个结构体类型可以定义出多个不同的结构体变量。 C++中
    每一个实体都是对象。有一些对象是具有相同的结构和特性的。每个对象都属于一个特定的类型,这个特定的类型称为类(class )。

    类代表了某一批对象的共性和特征。前面已说明:类是对象的模板,而对象是类的具体实例(instance)。

    正如同结构体类型和结构体变量的关系一样,需要先声明一个结构体类型,然后用它去定义结构体变量。同一个结构体类型可以定义出多个不同的结构体变量。

    在C++中也是先声明一个类类型,然后用它去定义若干个同类型的对象。对象就是类类型的一个变量。可以说类是对象的模板,是用来定义对象的一种抽象类型。

    类是抽象的,不占用内存,而对象是具体的,占用存储空间。

    类的声明

    类是用户自己指定的类型。如果程序中要用到类类型,必须自己根据需要进行声明,或者使用别人已设计好的类。C++标准本身并不提供现成的类的名称、结构和内容。

    在C++中声明一个类类型和声明一个结构体类型是相似的。下面是声明一个结构体类型的方法:
    struct Student //声明了一个名为Student的结构体类型
    {
        int num;
        char name[20];
        char sex;
    };
    Student stud1, stud2;  //定义了两个结构体变量stud1和stud2,它只包括数据,没有包括操作
    现在声明一个类:
    class Student //以class开头
    {
       int num;
       char name[20];
       char sex; //以上3行是数据成员
       void display( ) //这是成员函数
       {
          cout<<"num:"<<num<<endl;
          cout<<"name:"<<name<<endl;
          cout<<"sex:"<<sex<<endl;
          //以上4行是函数中的操作语句}
       }
    };
    Student stud1,stud2; //定义了两个Student 类的对象stud1和stud2
    可以看到声明类的方法是由声明结构体类型的方法发展而来的。第1行“class Student" 是类头(class head),由关键字class与类名Student组成,class是声明类时必须使用的关键字,相当于声明结构体类型时必须用struct —样。从第2行开头的左花括号起到倒数第2行的右花括号是类体(class body)。也就是说,类体是用一对花括号包起来的。类的声明以分号结束。

    在类体中是类的成员列表(class member list),列出类中的全部成员。可以看到除了 数据部分以外,还包括了对这些数据操作的函数。这就体现了把数据和操作封装在一起。 display是一个函数,对本对象中的数据进行操作,其作用是输出本对象中学生的学号、姓 名和性别。

    可以看到,类(class )就是对象的类型。实际上,类是一种广义的数据类型。类这种数据类型中的数据既包含数据,也包含操作数据的函数。

    现在封装在类对象stud1和stud2中的成员都对外界隐蔽,外界不能调用它们。只有本对象中的函数display可以引用同一对象中的数据。也就是说,在类外不能直接调用类 中的成员。这当然“安全"了,但是在程序中怎样才能执行对象studl的display函数呢?它无法启动,因为缺少对外界的接口,外界不能调用类中的成员函数,完全与外界隔绝了。 这样的类有什么用处呢?显然是毫无实际作用的。因此,不能把类中的全部成员与外界 隔离,一般是把数据隐蔽起来,而把成员函数作为对外界的接口。例如,可以从外界发出 —个命令,通知对象stud1执行其中的display函数,输出某一学生的有关数据。

    可以将上面类的声明改为:
    class Student //声明类类型
       {
    private : //声明以下部分为私有的
       int num;
       char name[20];
       char sex;
    public : //声明以下部分为公用的
       void display( )
       {
          cout<<"num:"<<num<<endl;
          cout<<"name:"<<name<<endl;
          cout<<"sex:"<<sex<<endl;
       }
    };
    Student stud1,stud2; //定义了两个Student类的对象
    如果在类的定义中既不指定private,也不指定public,则系统就默认为是私有的。

    归纳以上对类类型的声明,可得到其一般形式如下:
        class 类名
        {
            private :
                私有的数据和成员函数;
            public :
                公用的数据和成员函数;
        };

    private和public称为成员访问限定符(member access specifier)。除了private和public之外,还有一种成员访问限定符protected(受保护的),用protected声明的成员称为受保护的成员,它不能被类外访问(这点与私有成员类似),但可以被派生类的成员函数访问。

    在声明类类型时,声明为private的成员和声明为public的成员的次序任意,既可以先出现private部分,也可以先出现public部分。如果在类体中既不写关键字private,又不写public,就默认为private。

    在一个类体中,关键字private和public可以分别出现多次。每个部分的有效范围到出现另一个访问限定符或类体结束时(最后一个右花括号)为止。但是为了使程序清晰,应该养成这样的习惯,使每一种成员访问限定符在类定义体中只出现一次。

    在以前的C++程序中,常先出现private部分,后出现public部分,如上面所示。现在的C++ 程序多数先写public部分,把private部分放在类体的后部。这样可以使用户将注意力集中在能被外界调用的成员上,使阅读者的思路更清晰一些。

    在C++程序中,经常可以看到类。为了用户方便,常用的C++编译系统往往向用户提供类库(但不属于C++语言的组成部分),内装常用的基本的类,供用户使用。不少用户也把自己或本单位经常用到的类放在一个专门的类库中,需要用时直接调用,这样就减少了程序设计的工作量。

    对象的定义

    上面的程序中,最后一行用已声明的Student类来定义对象,这种方法是很容易理解的。经过定义后,stud1和stud2就成为具有Student类特征的对象。stud1和stud2这两个对象都分别包括Student类中定义的数据和函数。

    定义对象也可以有以下几种方法。

    1) 先声明类类型,然后再定义对象
    前面用的就是这种方法,如
        Student stud1, stud2;  //Student是已经声明的类类型在C++中,声明了类类型后,定义对象有两种形式。

    应该说明,在C++中,在声明了类类型以后,定义对象有两种形式。

    ①class 类名 对象名
    如 class Student stud1,stud2;
    把class和Student合起来作为一个类名,用来定义对象。

    ②类名 对象名
    如 Student stud1,stud2;
    直接用类名定义对象。

    这两种方法是等效的。第1种方法是从C语言继承下来的,第2种方法是C++的特色,显然第2种方法更为简捷方便。

    2) 在声明类类型的同时定义对象
    class Student//声明类类型
    {
    public ://先声明公用部分
       void display( )
       {
          cout<<"num:"<<num<<endl;
          cout<<"name:"<<name<<endl;
          cout<<"sex:"<<sex<<endl;
       }
    private ://后声明私有部分
       int num;
       char name[20];
       char sex;
    }stud1,stud2;//定义了两个Student类的对象
    在定义Student类的同时,定义了两个Student 类的对象。

    3) 不出现类名,直接定义对象
    class //无类名
    {
        private : //声明以下部分为私有的
        ┆
        public : //声明以下部分为公用的
        ┆
    }stud1, stud2;//定义了两个无类名的类对象

    直接定义对象,在C++中是合法的、允许的,但却很少用,也不提倡用。在实际的程序开发中,一般都采用上面3种方法中的第1种方法。在小型程序中或所声明的类只用于本程序时,也可以用第2种方法。在定义一个对象时,编译系统会为这个对象分配存储空间,以存放对象中的成员。

    类和结构体类型的异同

    C++增加了class类型后,仍保留了结构体类型(struct ),而且把它的功能也扩展了。C++允许用struct来定义一个类型。如可以将前面用关键字class声明的类类型改为用关键字struct:
    struct Student //用关键字struct来声明一个类类型
    {
    private : //声明以下部分为私有的
       int num;//以下3行为数据成员
       char name[20];char sex;
       public: //声明以下部分为公用的
       void display( ) //成员函数
       {
          cout<<"num:"<<num<<endl;cout<<"name:"<<name<<endl;cout<<"sex:"<<sex<<endl;
       }
    };
    Student stud1, stud2;//定义了两个Student类的对象

    为了使结构体类型也具有封装的特征,C++不是简单地继承C的结构体,而是使它也具有类的特点,以便于用于面向对象程序设计。用struct声明的结构体类型实际上也就是类。用struct声明的类,如果对其成员不作private或public的声明,系统将其默认为public。

    如果想分别指定私有成员和公用成员,则应用private或public作显式声明。

    而用class定义的类,如果不作private或public声明,系统将其成员默认为private,在需要时也可以自己用显式声明改变。如果希望成员是公用的,使用struct比较方便,如果希望部分成员是私有的,宜用class。建议尽量使用class来建立类,写出完全体现C++风格的程序。
    展开全文
  • 对于C++类中数据成员为类类型时,定义对象还是定义为指针,用哪种方法,并没有绝对的情况,需要根据具体情况具体分析。本质上是对象分配区域的问题,前者是栈(stack)上分配空间,后者是堆(heap)上分配空间。...
    对于C++类中数据成员为类类型时,定义为对象还是定义为指针,用哪种方法,并没有绝对的情况,需要根据具体情况具体分析。
    本质上是对象分配区域的问题,前者是在栈(stack)上分配空间,后者是在堆(heap)上分配空间。
    一般来说,可以定义为对象,在如下情况考虑把数据成员定义成指针,
    1)有多态的情况;会用到虚函数,基类指针
    2)可能和别的类共享,或者只是引用别的类里的某个对象,所以生命周期不是很确定(这个可以考虑智能指针)

    3)大数据类,如果定义成对象,会导致当前对象无法在栈内创建


    展开全文
  • 普通的数据成员只能声明为所属类类型的指针或者引用 因为声明的静态数据成员不占用对象的内存。但是普通的数据成员初始化呢的时候,首先要为对象分配内存,然后里面又有一个类,一直持续下去就不行,会无限迭代的...

    可以定义自身的static对象,但是非static的对象就不可以。

    静态数据成员的类型可以是所属类的类型,但是普通的数据成员不可以。普通的数据成员只能声明为所属类类型的指针或者引用

    因为声明的静态数据成员不占用对象的内存。但是普通的数据成员在初始化呢的时候,首先要为对象分配内存,然后里面又有一个类,一直持续下去就不行,会无限迭代的分配内存。当然,引用和指针是可以的。引用和指针的大小是固定的。

    例如:

    class A {

    private:

    int i;

    static A a;}

    A 的大小其实只是 i 的大小。


    展开全文
  • C++类中数据成员为类类型时,定义对象还是定义为指针? http://www.cppblog.com/aurain/archive/2012/11/18/195327.html C++中,ClassTest objTest;就已经构造了对象,分配了空间;而C#,Java中ClassTest...
  • 定义类 声明对象 创建对象 实例化对象 属性 对象调用属性或者方法 举例,下面定义类了一个声明属性,写了一个方法: class Person { public String name; //声明属性 public int age; //声明属性 ...
  • 最近看一本《c缺陷与陷阱》,意识到大型程序时对象声明定义的重要性 普通变量的定义声明 每个外部对象都必须程序的某个地方进行定义。因此如果一个程序中包含了语句 extern int a;//声明变量a ...
  • //类的声明类定义: class dog{ //类的定义}; 当用实例化一个类的对象时,编译器会根据类的定义来分配相应的存储空间 。也就是说,创建对象前,一定要有完整的类定义,这样编译器才能正确的计算所需空间。 ...
  • 因为对一个来说,我们创建它的对象之前该必须被定义过,而不能仅仅被声明。 否则,编译器就无法了解这样的对象需要多少存储空间。类似的,也必须首先被定义,然后 才能引用或者指针访问其成员。毕竟,...
  • java之定义对象的创建

    千次阅读 2018-12-28 17:23:27
    的基本结构  如果一切都是对象,那么是什么决定某一类对象的行为与外观呢?... 当用户创建一个Java程序时,可以通过类声明定义类。通常,这些里没有main方法,只有一些属性和方法。一个完...
  • Go 定义对象()的方法

    千次阅读 2019-03-20 18:20:21
    demo.go(定义对象()的方法): package main import "fmt" ...// 定义对象()的方法: func (对象类型参数)方法名(参数列表)(返回值列表){ } func (obj MyInt) add(b int) int { // 对象调...
  • 面向对象基础——对象定义

    千次阅读 2016-03-26 11:18:32
    定义类对象的方法? 类图的画法:Person类图 分为三层: 第一层表示的名称,的名称与之前一样要求开头首字母大写。 第二层表示属性的定义,按照" 访问权限 属性名称:属性类型 " 的格式定义; 第三层表示...
  • cpp————声明 定义 实现

    千次阅读 2017-02-10 15:56:13
    概述 是c++引入的核心数据类型是对数据和方法的封装,地位上与内置类型(复合类型)...声明不能用于实例对象,因为对于实例对象,编译器需要知道class具体细节以便确定分配多少内存空间,如何操作实例对象 c
  • 在类定义和成员函数的定义中,总结下需要注意的地方。  1.私有成员和函数,使用对象的程序不能直接访问,必须通过公有部分的函数或者是成员才能访问,否则会出现错误。可以公有成员函数定义中直接使用私有...
  • 定义自身对象

    千次阅读 2018-06-27 16:52:33
    C++的类定义中,是不能够在类定义自身对象的,但是可以定义自身的指针对象和引用。class A{public: A () { cout&lt;&lt;"Constructor method."&lt;&lt;endl; }; A a;}; ...
  • //【任务3】阅读P314的例10.1(电子版的平台上见txt文件)。...//使实部和虚部的类型定义对象时用的实际类型。 //(1)要求成员函数在类外定义。 //(2)此基础上,再实现减法、乘法和除法
  • C++中的——定义声明

    万次阅读 多人点赞 2018-08-23 10:49:04
    以面向对象的方式开发应用程序时,将遇到的各种事物抽象为中通常包含数据和操作数据的方法,用户通过实例化类对象来访问中的数据和方法。 一、定义 class/struct 类名 //头 {数据和方法的定义...
  • 声明定义

    千次阅读 2017-03-27 15:07:34
     在声明之后、定义之前,screen是一个不完全类型,即已知screen是一个类型,但不知道包含哪些成员。  不完全类型只能以有限的方式使用。不能用来定义类型对象,只能用于定义指向该类型的指针及引用,或用于...
  • C++定义对象:Circle

    千次阅读 2015-03-26 19:02:34
    【3.22 】声明一个Circle,有数据成员radius(半径)、成员函数area(),计算圆的面积,构造一个Circle的对象进行测试。 #include #include using namespace std; class Circle{ //声明 double r; //定义圆的...
  • 结构体类型声明定义的标准形式
  • python3 类对象定义、方法

    万次阅读 2017-10-26 22:09:28
    Class 对象定义、方法面向对象定义类 Class: 用来描述具体相同的属性和方法的对象的集合。定义了该集合中每个对象所共有的属性和方法。对象的示例。变量:变量整个实例化的对象中是公用的。变量...
  • c++模板类声明定义的问题

    千次阅读 2019-08-18 21:38:39
    c++模板是泛型编程的基础,所谓泛型编程也是一种思想,一种抽象数据类型,但是泛型是不属于面向对象,它是面向对象的补充和发展。使用泛型编程简单来说就是能让你把一些相同的代码用指定的去替换它,算是程序员找到的...
  • 对象定义以及四种初始化方式

    千次阅读 2018-04-26 22:10:31
    对象是真正存在的实体,是具体的事物 是对实体的一种抽象,也可以看做是一种模板,对象则是使用模板制造的多个实物 ...那么我们如何来定义一个? class Person{ private String name; ...
  • //【任务3】阅读P314的例10.1...//使实部和虚部的类型定义对象时用的实际类型。 //(1)要求成员函数在类外定义。 //(2)此基础上,再实现减法、乘法和除法 /* (程序头部注释开始) * 程序的版权和版本声明部分
  • /* (程序头部注释开始) * 程序的版权和版本声明部分 ...* 文件名称:实现一个复数,通过模板的技术手段,设计Complex,使实部和虚部的类型定义对象时用的实际类型 * 作 者: 雷恒鑫 *
  • 定义对象  面向对象程序设计(OOP)就是使用对象进行程序设计。对象(object)代表现实世界中可以明确标识的一个实体。例如:一个学生、一张桌子、一个圆、一个按钮甚至一笔贷款都可以看做是一个对象,每个...
  • 声明定义与初始化

    千次阅读 2012-01-05 09:46:24
    不完全只能用于定义指针、引用、参数类型、返回值类型,不能定义对象class Mat; //求定义的 Mat Test(Mat& B);//正确 Mat *pMat;//正确 Mat mt;//错误,如果任何位置(即使是这句话的后面)定义了这个,这...
  • 可以通过模板的技术手段,设计Complex,使实部和虚部的类型定义对象时用的实际类型。 (1)要求成员函数在类外定义。 (2)此基础上,再实现减法、乘法和除法 你可以使用的main()函数如下。 int main( )...
  • 类声明:  class dog;...也就是说,创建对象前,一定要有完整的类定义,这样编译器才能正确的计算所需空间。  那么我们来看如下代码: class dog{  dog tt; //error, ‘tt’ uses undefined class...
  • c++中模板_模板的声明定义

    千次阅读 2017-11-17 11:24:18
    一、函数模板用法 1.1申明和定义 Ø 函数申明和定义前面,加一个模板...Ø 模板的声明定义只能全局,命名空间或范围内进行。即不能局部范围,函数内进行,比如不能main函数中声明定义一个模板 1....

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 730,137
精华内容 292,054
关键字:

在声明类类型的同时定义对象