精华内容
下载资源
问答
  • C++类的成员函数(在类外定义成员函数)
    千次阅读
    2021-04-25 21:37:04

    类的成员函数(简称类函数)是函数的一种,它的用法和作用和前面介绍过的函数基本上是一样的,它也有返回值和函数类型,它与一般函数的区别只是:它是属于一个类的成员,出现在类体中。它可以被指定为private(私有的)、public (公用的)或protected(受保护的)。

    在使用类函数时,要注意调用它的权限(它能否被调用)以及它的作用域(函数能使用什么范围中的数据和函数)。例如私有的成员函数只能被本类中的其它成员函数所调用,而不能被类外调用。成员函数可以访问本类中任何成员(包括私有的和公用的),可以引用在本作用域中有效的数据。

    一般的做法是将需要被外界调用的成员函数指定为public,它们是类的对外接口。但应注意,并非要求把所有成员函数都指定为public。有的函数并不是准备为外界调用的,而是为本类中的成员函数所调用的,就应该将它们指定为private。这种函数的作用是支持其它函数的操作,是类中其它成员的工具函数(utility function),类外用户不能调用这些私有的工具函数。

    类的成员函数是类体中十分重要的部分。如果一个类中不包含成员函数,就等同于C语言中的结构体了,体现不出类在面向对象程序设计中的作用。

    在类外定义成员函数

    在前面已经看到成员函数是在类体中定义的。也可以在类体中只写成员函数的声明,而在类的外面进行函数定义。如:

    class Student
    {
    public :
    void display( ); //公用成员函数原型声明
    private :
    int num;
    string name;
    char sex;
    //以上3行是私有数据成员
    };
    void Student::display( )//在类外定义display类函数
    {
    cout<<"num:"<<num<<endl;
    cout<<"name:"<<name<<endl;
    cout<<"sex:"<<sex<<endl;
    }
    Student stud1,stud2; //定义两个类对象
    

    注意:在类体中直接定义函数时,不需要在函数名前面加上类名,因为函数属于哪一个类是不言而喻的。

    但成员函数在类外定义时,必须在函数名前面加上类名,予以限定(qualifed)," :: "是作用域限定符(field qualifier)或称作用域运算符,用它声明函数是属于哪个类的。

    如果在作用域运算符“::”的前面没有类名,或者函数名前面既无类名又无作用域运算符“::”,如
    ::display( ) 或 display( )
    则表示display函数不属于任何类,这个函数不是成员函数,而是全局函数,即非成员函数的一般普通函数。

    类函数必须先在类体中作原型声明,然后在类外定义,也就是说类体的位置应在函数定义之前,否则编译时会出错。

    虽然函数在类的外部定义,但在调用成员函数时会根据在类中声明的函数原型找到函数的定义(函数代码),从而执行该函数。

    在类的内部对成员函数作声明,而在类体外定义成员函数,这是程序设计的一种良好习惯。如果一个函数,其函数体只有2-3行,一般可在声明类时在类体中定义。多于3行的函数,一般在类体内声明,在类外定义。

    更多相关内容
  • 成员可以包括什么?

    千次阅读 2020-12-27 22:26:25
    和对象可以说是一个抽象与具体的例子吧,将一个具有共同属性的集合高度概括为一个抽象的“(Class)”,创建一个Class后可以将它实例化为许多具体的“对象”。我们借用和对象来实现我们所需要的功能。 创建...

    首先:创建类以及实例化对象的基本语法如下:

    // 创建类
    class <class_name>{ 
      field;//也叫字段/属性/成员变量(field)
      method;//成员方法
    }
    // 实例化对象
    <class_name> <对象名> = new <class_name>();
    

    Q:类的成员可以包括什么?
    A:类的成员可以包含:字段、方法、代码块、内部类和接口等。

    "示例:"
    public class Person {
      //1--字段、属性,成员变量"
      public String name;  
      public int age;
      public static String STATIC_FIELD = "静态属性";
      
      //2--代码块分为普通代码块 静态代码块 构造代码块" 
      //"2.1构造代码块"
      {
            System.out.println("第一构造块");
      }
     // "构造方法"
      public Person (int i) {
            System.out.println("第" + i + "次调用" + "构造方法");
        }
        
      //"2.2静态代码块"
        static {
            System.out.println(STATIC_FIELD);
            System.out.println("静态代码块1");
        }
        
      //"3--方法"
      public void show() {
      	//"2.3普通代码块"
     	System.out.println("我叫" + name + ", 今年" + age + "岁");
      }
      
      //4--内部类
      class Draw {     
            public void drawShape() {
                System.out.println("draw");
            }
        }
       //5--接口
       public interface Eat {
            public String info();
        }
      
      //main()方法
     public static void main(String[] args) {
        Person person = new Person();//创建对象
        //使用new 关键字用于创建一个对象的实例;
        //使用 . 来访问对象中的属性和方法.;同一个类可以创建多个实例。
        System.out.println(person.name);
        person.show();//调用方法
    }
    
    • 类Draw是类Person的一个成员,Person称为外部类。成员内部类Draw可以无条件访问外部类的所有成员属性和成员方法(包括private成员和静态成员)
    • 需要注意,内部接口不管有没有声明static,都是静态的。这不同于成员内部类,成员内部类需要依赖其所在类实现的对象

    ——————————————————————————————————

    字段(field)

    • 初始化的三种方式:
      ①就地初始化,public String name = "张三";
      ②默认初始化public String name; 默认值为null;
      ③类外初始化。类外初始化在项目工程中使用频繁。
      对于一个对象的字段如果没有显式设置初始值, 那么会被设置一个默认的初值;

    默认值规则
    1、对于各种数字类型, 默认值为 0.
    2、对于 boolean 类型, 默认值为 false.
    3、对于引用类型(String, Array, 以及自定制类), 默认值为 null

    方法 (method)

    • 语法规则
      1.方法名称必须与类名称相同
      2.构造方法没有返回值类型声明
      3.每一个类中一定至少存在一个构造方法(没有明确定义,则系统自动生成一个无参构造)

    • 方法中还有一种特殊的方法称为 构造方法 (construction method)
      在使用关键字new实例化对象的时候会被自动调用到的方法, 方法名字和类名相同, 用于完成对象的初始化操作.

      这里就不得不提到new 执行过程,总共分为2步:
      1、为对象分配内存空间
      2、调用对象的构造方法

    • 注意事项
      1、如果类中没有提供任何的构造函数,那么编译器会默认生成一个不带有参数的构造函数
      2、若类中定义了构造方法,则默认的无参构造将不再生成.
      3、构造方法支持重载. 规则和普通方法的重载一致

    关键字static
           关于static修饰的属性和方法都使用类名.方法/属性来调用;因为静态的方法和属性就已经不依赖于对象了。同一个类的不同实例共用同一个静态属性.例如如下代码:

    class TestDemo{
      public int a;
      public static int count;  //静态成员变量
    }
    public class Main{
     
    public static void main(String[] args) {
        TestDemo t1 = new TestDemo();
        t1.a++;
        TestDemo.count++;
        System.out.println(t1.a);//1
        System.out.println(TestDemo.count);//1
        //实例化多个对象
        TestDemo t2 = new TestDemo();
        t2.a++;
        TestDemo.count++;//使用类名.属性来调用
        //无需创建实例对象 就可以调用
        System.out.println(t2.a);//1
        System.out.println(TestDemo.count);//2 
        //因为是共用的所以count从1变到2
     }
    }
    

    注:static可以修饰属性、修饰方法、代码块、修饰类

    修饰限定符 private/ public 这两个关键字表示 “访问权限控制”
    被 public 修饰的成员变量或者成员方法,可以直接被类的调用者使用.
    被 private 修饰的成员变量或者成员方法, 不能被类的调用者使用

    类和对象

           类和对象可以说是一个抽象与具体的例子,将一个具有共同属性的集合高度概括为一个抽象的“类(Class)”,在创建一个Class后可以将它实例化为许多具体的“对象”。我们借用类和对象来实现我们所需要的功能。

    class Person {
      public int age;//实例变量  
      public String name;//实例变量
      public String sex;//实例变量均存放在对象内
      public static int count;//类变量也叫静态变量,编译时已经产生,属于类本身,且只有一份。存放在方法区
      public final int SIZE = 10;//被final修饰的叫常量,也属于对象。 被final修饰,后续不可更改,存放在对象内
      public static final int  COUNT = 99;//静态的常量,属于类本身,只有一份 被final修饰,后续不可更,存放在方法区//实例成员函数
      public void eat() {
       int a = 10;//局部变量
       System.out.println("eat()!"); 
     }
     
      //实例成员函数
      public void sleep() {
       System.out.println("sleep()!"); 
     }
     
      //静态成员函数
      public static void staticTest(){
        //不能访问非静态成员
        //sex = "man"; error
        System.out.println("StaticTest()");
      }
    }
    
    public class Main{
    public static void main(String[] args) {
        //产生对象 实例化对象
        Person person = new Person();//person为对象的引用
        System.out.println(person.age);//默认值为0
        System.out.println(person.name);//默认值为null
        //System.out.println(person.count);//会有警告!
        //正确访问方式:
        System.out.println(Person.count);
        System.out.println(Person.COUNT);
        Person.staticTest();
        //总结:所有被static所修饰的方法或者属性,全部不依赖于对象。
        person.eat();
        person.sleep();
    }
    }
    

    下图为数据属性的内存布局:
    在这里插入图片描述

    展开全文
  • 定义一个Box(盒子),定义中包括数据成员: length(长),width(宽)和height(定义一个Box(盒子),定义中包括数据成员: length(长),width(宽)和height(定义一个Box(盒子),定义中包括数据成员: ...

    定义一个Box(盒子)类,在该类定义中包括数据成员: length(长),width(宽)和height(

    定义一个Box(盒子)类,在该类定义中包括数据成员: length(长),width(宽)和height(

    定义一个Box(盒子)类,在该类定义中包括数据成员: length(长)、width(宽)和height(高);成员函数: 构造函数Box,设置盒子长、宽和高三个初始数据;用函数volume 计算并输出盒子的体积.在main函数中,要求创建Box对象,并求盒子的体积.

    int main()

    {

    Box b1,b2(2,3,4);

    float v1,v2;

    v1 = b1.GetVolume();

    v2 = b2.GetVolume();

    if (v1>v2)

    cout<

    else

    cout<

    return 0;

    }

    人气:747 ℃时间:2020-04-26 06:51:23

    优质解答

    #include 

    using namespace std;

    class Box {

    \x09float length, width, height;

    public:

    \x09Box(float l, float w, float h);

    \x09float GetVolume() const;

    };

    Box::Box(float l = 1, float w = 1, float h = 1)

    \x09: length(l), width(w), height(h) {}

    float Box::GetVolume() const {

    \x09return height * width * length;

    }

    int main()

    {

    \x09Box b1, b2(2, 3, 4);

    \x09float v1, v2;

    \x09v1 = b1.GetVolume();

    \x09v2 = b2.GetVolume();

    \x09if (v1>v2)

    \x09\x09cout <

    \x09else

    \x09\x09cout <

    \x09return 0;

    }Box b1, b2(2, 3, 4);

    这行有错哎~error C2512: 'Box' : no appropriate default constructor available

    怎么改呢???#include 

    using namespace std;

    class Box {

    \x09float length, width, height;

    public:

    \x09Box();

    \x09Box(float l, float w, float h);

    \x09float GetVolume() const;

    };

    Box::Box() : length(1), width(1), height(1) {}

    Box::Box(float l, float w, float h)

    : length(l), width(w), height(h) {}

    float Box::GetVolume() const {

    \x09return height * width * length;

    }

    int main()

    {

    \x09Box b1, b2(2, 3, 4);

    \x09float v1, v2;

    \x09v1 = b1.GetVolume();

    \x09v2 = b2.GetVolume();

    \x09if (v1>v2)

    \x09\x09cout <

    \x09else

    \x09\x09cout <

    \x09return 0;

    }

    我来回答

    类似推荐

    展开全文
  • C++命名空间中声明类成员函数

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

    首先关于前置声明,有以下几点要注意:

    b.h头文件中引入类a时,有两种方式,前置声明和 #include a.h”,建议使用前置声明,当a.h的私有成员改变时,b.h不需要重新编译。所以能用前置声明代替#include 的时候,尽量用前置声明 。

    使用前置声明注意事项:B类中成员A  a编译器为a分配内存空间的时候必须知道d的大小,所以应该改成指针代替,A *a

     

    其次关于命名空间:

    1、为什么引入命名空间?

    首先可以假定这样一个情景:

    在文件中可以定义全局变量,它的作用域是整个程序。如果在文件A中定义了一个变量a int a=3

    在文件B中可以再定义一个变量a int a=5;

    在分别对文件A和文件B进行编译时不会有问题。但是,如果一个程序包括文件A和文件B,那么在进行连接时,会报告出错,因为在同一个程序中有两个同名的变量,认为是对变量的重复定义。

     

    由此可以引入命名空间:实际上就是一个由程序设计者命名的内存区域,程序设计者可以根据需要指定一些有名字的空间域,把一些全局实体分别放在各个命名空间中,从而与其他全局实体分隔开来。

    2、使用命名空间成员的方法

        使用命名空间别名:namespace Television //声明命名空间可以用一个较短而易记的别名代替它。如:

    namespace TV=Television//别名TV与原名Television等价

    使用using命名空间成员名:using后面的命名空间成员名必须是由命名空间限定的名字。例如: using nsl::Student

    以上语句声明:在本作用域(using语句所在的作用域)中会用到命名空间ns1中的成员Student,在本作用域中如果使用该命名空间成员时,不必再用命名空间限定。例如在用上面的using声明后,在其后程序中出现的Student就是隐含地指nsl::Student

    using声明的有效范围是从using语句开始到using所在的作用域结束。

    3、标准命名空间std

    我们每次写c++时头文件都会写Using namespace std;这是什么意思呢?

    其实,标准C++库的所有的标识符都是在一个名为std的命名空间中定义的,或者说标准头文件(iostream)中函数、类、对象和类模板是在命名空间 std中定义的。stdstandard(标准)的缩写,表示这是存放标准库的有关内容的命名空间,含义请楚,不必死记。

     

     

    为什么使用命名空间的前置声明:

    很多时候,你是在一个专门的头文件中声明一个类并在不同的源文件中独立地定义其成员函数。那么如何将命名空间成员类分离成多个源文件呢?

    下面举例说明:
    下面是名为 Foo.hpp 的头文件,其中定义了一个名为NS的命名空间,它包含类Foo的声明:

    //Foo.hpp

    namespace NS

    {

    class Foo

    {

    public:

    void f();

    void g();

    };

    }//close NS

    另外,在一个单独的源文件Foo.cpp中,首先包含头文件Foo.hpp以便实现类Foo的成员函数f()g()

    //Foo.cpp

    #include "Foo.hpp"

    void NS::Foo::f()

    { /*..*/ }

    void NS::Foo::g()

    { /*..*/ }

    为了使用命名空间成员,必须使用成员的全路径名,它由命名空间后跟::合成原名组成。因此,类Foo的全路径名是NS::Foo。这样编译器便可以知道NS是一个名字空间名,头文件Foo.hpp必须在引用NS之前被包含。

    命名空间是可以扩展的。也就是说可以声明类,而且所声明的类在其它的.cpp文件中是相同的命名空间成员:

    //Bar.hpp

    namespace NS //扩展 NS

    {

    class Bar

    {

    public:

    void a();

    void b();

    };

    }

    Bar.cpp文件中:

    #include "Bar.hpp"

    void NS::Bar::a()

    {/*..*/}

    void NS::Bar::b()

    {/*..*/}

     

    使用方式有两种:1using NS::Bar; //使用命名空间

    2、NS::Bar b; //全路径名

     

     

    下面为转载的其他博客的关于命名空间中类定义和具体使用的实例:

    网址:https://blog.csdn.net/wb175208/article/details/79986445

    SpaceA.h

    #pragma oncenamespace TestA {

        class SpaceA {

        public:

            SpaceA();

            ~SpaceA();

     

            void print();

        };

    }

    SpaceA.cpp

    #include "SpaceA.h"using namespace TestA;

     

    SpaceA::SpaceA() {

    }

     

     

    SpaceA::~SpaceA() {

    }

    void SpaceA::print() {

        int i = 0;

        i++;

    }

    SpaceB.h

    #pragma once

    //在使用之前声明一下

    namespace TestA {

        class SpaceA;

    }

     

    namespace TestB {

        class SpaceB {

        public:

            SpaceB();

            ~SpaceB();

            void printB();

        private:

            TestA::SpaceA* a;//使用的时候,必须加上命名空间

        };

     

    }

    SpaceB.cpp

    #include "SpaceB.h"#include "SpaceA.h"using namespace TestB;using namespace TestA;

     

    SpaceB::SpaceB() {

        a = new SpaceA;

    }

     

    SpaceB::~SpaceB() {

    }

    void SpaceB::printB() {

        int i = 9;

        i++;

        a->print();

    }

    在使用的时候:

    #include "SpaceB.h"using namespace TestB;

    int main(int argc, char *argv[]){

     

        SpaceB b;

        b.printB();

    }

     

    谢谢观看!如有错误,请指正!

    展开全文
  • 类的成员函数(简称类函数)是函数的一种,它的用法和作用和前面介绍过的函数基本上是一样的,它也有返回值和函数类型,它与一般函数的区别只是:它是属于一个类的成员,出现在类。它可以被指定为private(私有的...
  • 类中成员的访问权限_Java语言程

    千次阅读 2021-03-17 10:29:14
    ·私有(private)成员:仅的代码可访问它。·默认(无修饰符)成员同一包内的代码可访问它。·保护(protected)成员同一包内及其子类(不同包)的代码可访问它。·公共(public)成员...
  • C++ 类中数据成员分布详解

    千次阅读 2018-12-22 23:39:13
    我们都知道类中包含着数据成员,但是数据成员在内存是怎样分布的呢?继承之后数据又是怎样布局的呢?下面对这些问题进行整理。的空间分布是编译器编译的结果,不同的编译器有可能会不一样,但是原理是一样的。 ...
  • 题目:声明一个名为Person的,该类中包含成员变量:姓名、出生年月、性别,包含成员方法:显示姓名、出生年月、性别,并main函数创建一个Person实例,调用其成员方法,打印出姓名、出生年月以及性别信息。...
  • 这个const一般是对类中成员函数属性的声明,但这个声明怪怪的,只能放在函数声明的尾部,大概是因为其它地方都已经被占用了。这个声明表示任这个函数不会修改类中的数据成员。如果编写const成员函数时,不慎修改了...
  • 的定义:类声明体。基本格式如下: class 类名{ 体 } 特点: 1、是Java程序的基本要素,一个Java应用程序就是由若干个所构成; 2、类声明的变量称为对象变量,也简称 对象 ; 3、class 关键字是...
  • Java 成员有哪些?

    千次阅读 2019-05-29 10:13:35
    成员有5:属性、方法、构造器、代码块、内部 :具有相同属性(特征)和行为(动作)对象的集合,是抽象出来的。 属性:描述类型的的特征(未完待续…) ...
  • const 表示对类中成员函数属性的声明; 表示不会修改类中的数据成员编写const成员函数时,若不慎修改了数据成员,或者调用了其他非const成员函数,编译器将指出错误; 以下程序stack的成员函数...
  • 最近c++课程布置了第一次作业,虽然之前...本题要求根据给定的Car声明,实现其成员函数。 和函数接口定义: class Car //定义Car { //成员函数 public: void disp_welcomemsg(); //显示欢迎信息 int g...
  • C++——的定义和声明

    万次阅读 多人点赞 2018-08-23 10:49:04
    以面向对象的方式开发应用程序时,将遇到的各种事物抽象为类中通常包含数据和操作数据的方法,用户通过实例化对象来访问类中的数据和方法。 一、的定义 class/struct 类名 //头 {数据和方法的定义...
  • 定义一个Student定义中包括:两个数据成员name(学生姓名)和score(分数);两个静态数据成员total(总分)和count(学生人数)。成员函数scoretotalcount(float s)用于设置每个学生的分数;静态成员...
  • 浅谈C++类中6个成员函数

    千次阅读 多人点赞 2021-03-18 15:45:13
    构造函数是一个特殊的成员函数,名字与类名相同且不能有返回值,创建类型时由编译器自动调用,对象的生命周期内只调用一次。**主要任务是初始化对象。 ↓下面是一个简单的构造函数(全缺省): 主函数初始化时...
  • /*定义一个日期包括年、月、日三个成员变量,显示日期的方法* 提供构造方法:定义无参构造方法,和有参构造方法*/ 代码如下:public class Demo {public static void main(String[] args) {Date date1=new Date...
  • 也可以在类只写成员函数的声明,而在类的外面进行函数定义。如: class Student { public : void display( ); //公用成员函数原型声明 private : int num; string name; char sex; //以上3行是私有数据...
  • java中类的静态成员和实例成员

    千次阅读 2017-08-05 15:03:12
    java的静态成员包括静态方法和静态成员变量,静态成员都是由static修饰的; java的实例成员包括实例方法和实例成员变量,实例成员都没有被static修饰; 二:使用语法 关于使用静态成员和实例成员的具体语法规则如下...
  • 声明一个图书,其数据成员为书名、编号(利用静态变量实现自动编号)、书价,并拥有静态数据成员册数、记录图书的总册数,构造方法利用些静态变量为对象的编号赋值,主方法定义数组对象,并求出总册数
  • 一,前言 基于原型prototype的JS,一直模拟面向对象, ...TS,对ES6的进行了增强,引入了更多特性 二,定义一个 使用TS定义一个: class Dog { constructor(name: string) { this.name = name; } na...
  • 这个const一般是对类中成员函数属性的声明,但这个声明怪怪的,只能放在函数声明的尾部,大概是因为其它地方都已经被占用了。这个声明表示任这个函数不会修改类中的数据成员。如果编写const成员函数时,不慎修改了...
  • import java.text.... //常用日期操作工具import java.util.Calendar; //使用默认时区和语言环境获得一个日历import java.util.Date;public class Account { private String acountNumber; //账号 ...
  • 类的静态数据成员在 类内只能声明,定义和初始化必须在类外 可以这样 class a { int aa; static int aaa; //静态数据成员声明 }; int a::aaa=10; //静态数据成员的定义和初始化
  • 通过友元,一个不同函数或另一个类中成员函数可以访问类中的私有成员和保护成员。c++的友元为封装隐藏这堵不透明的墙开了一个小孔,外界可以通过这个小孔窥视内部的秘密。 友元的正确使用能提高程序的运行...
  • 本次程序对我来说有很大的难度,程序刚开始编写时遇到很多的问题,未导入Scanner,取款的算法、存款的算法等,更改了很多变之后才完成,自己这方面的知识还是比较欠缺,今后的学习会着重注意一下,多花点时间...
  • 本题要求声明和实现一个Car包括实现其成员函数。 要求如下: 和函数接口定义: 1. 声明一个Car; 2. 三个public成员函数: (1) disp_welcomemsg(),无返回类型; (2) get_wheels(),返回一个Car的数据成员...
  • 设计一个银行帐户成员变量包括账号、储户姓名、开户时间、身份证号码、存款余额等帐户信息,成员方法包括存款、取款操作 思路:首先创建一个BankAccount用于存放用户信息,创建一个BCOptionBCOption...
  • C++中类的(static)静态成员变量与(static)静态成员函数

    万次阅读 多人点赞 2018-08-04 11:27:28
    C++的类中,也有静态成员变量同时还有静态成员函数,先来看看C++静态成员变量与静态成员函数的语法: #include &lt;iostream&gt; #include &lt;string&gt; using namespace std; class ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 300,171
精华内容 120,068
关键字:

在类中声明的成员包括