精华内容
下载资源
问答
  • 在类中下面哪一个成员只能在
    千次阅读
    2020-03-05 20:06:07

           在继承之外,在C++中一个类成员函数调用另一个类成员的方法主要有:类的组合,友元类,类的前向声明,单例模式等,下面主要讲讲这4种方法的实现

    方法1:利用类的组合

    组合通俗来讲就是类B有类A的属性,如声明一个Person类,再声明一个Teacher类,Person类对象有年龄和姓名成员,而Teacher类对象成员也有年龄和姓名属性,所以我们可以将类Person的对象作为类Teacher的成员变量,那么就实现了Teacher类对象也有这两个属性。如下所示:

    #include<iostream>
    #include<string>
    using namespace std;
    
    class Person
    {
      public:
    	  Person(int _age, string _name) :age(_age), name(_name) {}
    	  ~Person() {};
    	void print() 
    	{
    		cout << name<<"	" << age  << endl;
    	}
    	private:
    		int age;
    	   string name;
    };
    class Teacher
    {
    public:
    	Teacher(Person* _person) :person(_person) {}
    	~Teacher() {};
    	void print()
    	{
    		this->person->print();
    	}
    	private:
    		Person* person;
    		
    };
    
    int main()
    {
    	Person p(40, "lisan");
    	Teacher teacher(&p);
    	teacher.print();
    	system("pause");
    	return 0;
    }
    

    方法2:友元类

    友元类就是在类A中声明一个类B,那么就称类B是类A的友元类,这时类B的对象可以访问类A的一切成员,包括私有成员。如下所示:

    #include<iostream>
    #include<string>
    using namespace std;
    
    class A
    {
    public:
    	friend class B;
    	A(int _age, string _name) :age(_age), name(_name) {}
    	~A() {};
    	void print_a()
    	{
    		cout << name << "	" << age << endl;
    	}
    private:
    	int age;
    	string name;
    };
    class B
    {
    public:
    	B() {};
    	~B() {};
    	void print_b(A& a)
    	{
    		a.print_a();
    	}
    };
    
    int main()
    {
    	A a(20,"name");
    	B b;
    	b.print_b(a);
    	system("pause");
    	return 0;
    }
    

    注意:

    1、友元类是单向的,即类B是类A的友元类,但类A不是类B的友元类
    1、友元类不能传递,即类B是类A的友元类,类C是类B的友元类,但类C不是类A的友元类

    3.前项声明

    使用前面两种方法,如果将两个类在不同的头文件中声明,则需要在第二个类中包含第一个类的头文件,但使用类的前向声明则不用使用#include"xxx",具体实现如下:

    代码段1:在person.h头文件
    #pragma once
    #ifndef _PERSON_H
    #define _PERSON_H
    #include <string>
    #include <iostream>
    class Person
    {
    public:
    	Person(int _age, std::string _name) :age(_age), name(_name) {}
    	~Person() {};
    	void print() const
    	{
    		std::cout << name << "	" << age << std::endl;
    	}
    private:
    	int age;
    	std::string name;
    };
    
    #endif
    

    代码段2:在teacher.h头文件中
    #pragma once
    #ifndef _TEACHER_H
    #define _TEACHER_H
    //#include "person.h"   //前两种方法
    
    class Person;  //类的前向声明
    class Teacher
    {
    public:
    	Teacher() {};
    	~Teacher() {};
    	void print(Person& person)
    	{
    		person.print();
    	}	
    };
    #endif
    
    代码段3:主文件main.cpp
    #include<iostream>
    #include "person.h"
    #include "teacher.h"
    int main()
    {
    	Person p(40, "lisan");
    	Teacher teacher;
    	teacher.print(p);
    	system("pause");
    	return 0;
    }
    

    注意:

    1、类的前向声明只能用于定义指针、引用、以及用于函数形参的指针和引用
    2、前向声明的类是不完全的类型,因为只进行了声明而没有定义

    前向声明的作用

    1、在预处理时,不需要包含#include"xxx",相对节约编译时间
    2、方便的解决两种类类型互相使用的问题。

    4.单例模式

    单例模式是程序设计模式中最常用的模式之一,其主要思想是将类的构造函数声明为私有的防止被外部函数实例化,内部保存一个private static的类指针保存唯一的实例,实例的实现由一个public的类方法代劳,该方法返回单例类唯一的实例。
    注意:

    采用单例模式的对象在进程结束才被释放。
    关于单例模式的详细内容大家可以去看单例模式的知识。下面是一个典型的单例例子:

    #include<iostream>
    #include<string>
    using namespace std;
    
    class Singleton 
    {
    public:
    	static Singleton* getInstance()
    	{
    		instance =  new Singleton();
    		return instance;
    	}
    	~Singleton() {};
    private:
    	Singleton() {};
    	static Singleton* instance;
    };
    

    下面看怎么在另一个类中使用单例模式实现成员函数的调用:

    class Singleton
    {
    public:
    	static Singleton* getInstance()
    	{
    		if (instance == nullptr)
    		{
    			instance = new Singleton();
    			return instance;
    		}
    		else
    			return  instance;
    	}
    	static void print_instance()
    	{
    		cout<<name <<" " <<age <<endl;
    	}
    	~Singleton() {};
    private:
    	Singleton() {};
    	static Singleton* instance;
    	static int age;
    	static string name;
    };
    
    int  Singleton::age = 20;
    string Singleton::name = "lisan";
    Singleton* Singleton::instance = nullptr;
    
    class A
    {
    
    public:
    	void print_a()
    	{
    		 Singleton::getInstance()->print_instance();
    	}
    
    };
    int main()
    {
    	A a;
    	a.print_a();
    	system("pause");
        return 0;
    }
    

    作者:xqs习惯就好 原文:https://blog.csdn.net/qq_35721743/article/details/83592415

    更多相关内容
  • 继承之外,C++中一个类成员函数调用另一个类成员的方法主要有:的组合,友元的前向声明,单例模式等,下面主要讲讲这4种方法的实现 方法1:利用的组合 组合通俗来讲就是B有A的属性,如声明一个...

    在继承之外,在C++中一个类成员函数调用另一个类成员的方法主要有:类的组合,友元类,类的前向声明,单例模式等,下面主要讲讲这4种方法的实现

    方法1:利用类的组合
    组合通俗来讲就是类B有类A的属性,如声明一个Person类,再声明一个Teacher类,Person类对象有年龄和姓名成员,而Teacher类对象成员也有年龄和姓名属性,所以我们可以将类Person的对象作为类Teacher的成员变量,那么就实现了Teacher类对象也有这两个属性。如下所示:

    #include<iostream>
    #include<string>
    using namespace std;

    class Person
    {
      public:
          Person(int _age, string _name) :age(_age), name(_name) {}
          ~Person() {};
        void print() 
        {
            cout << name<<"    " << age  << endl;
        }
        private:
            int age;
           string name;
    };
    class Teacher
    {
    public:
        Teacher(Person* _person) :person(_person) {}
        ~Teacher() {};
        void print()
        {
            this->person->print();
        }
        private:
            Person* person;
            
    };

    int main()
    {
        Person p(40, "lisan");
        Teacher teacher(&p);
        teacher.print();
        system("pause");
        return 0;
    }

    方法2:友元类
    友元类就是在类A中声明一个类B,那么就称类B是类A的友元类,这时类B的对象可以访问类A的一切成员,包括私有成员。如下所示:

    #include<iostream>
    #include<string>
    using namespace std;

    class A
    {
    public:
        friend class B;
        A(int _age, string _name) :age(_age), name(_name) {}
        ~A() {};
        void print_a()
        {
            cout << name << "    " << age << endl;
        }
    private:
        int age;
        string name;
    };
    class B
    {
    public:
        B() {};
        ~B() {};
        void print_b(A& a)
        {
            a.print_a();
        }
    };

    int main()
    {
        A a(20,"name");
        B b;
        b.print_b(a);
        system("pause");
        return 0;
    }

    注意:

    友元类是单向的,即类B是类A的友元类,但类A不是类B的友元类
    友元类不能传递,即类B是类A的友元类,类C是类B的友元类,但类C不是类A的友元类
    3.前项声明
    使用前面两种方法,如果将两个类在不同的头文件中声明,则需要在第二个类中包含第一个类的头文件,但使用类的前向声明则不用使用#include"xxx",具体实现如下:

    代码段1:在person.h头文件
    #pragma once
    #ifndef _PERSON_H
    #define _PERSON_H
    #include <string>
    #include <iostream>
    class Person
    {
    public:
        Person(int _age, std::string _name) :age(_age), name(_name) {}
        ~Person() {};
        void print() const
        {
            std::cout << name << "    " << age << std::endl;
        }
    private:
        int age;
        std::string name;
    };

    #endif

    代码段2:在teacher.h头文件中
    #pragma once
    #ifndef _TEACHER_H
    #define _TEACHER_H
    //#include "person.h"   //前两种方法

    class Person;  //类的前向声明
    class Teacher
    {
    public:
        Teacher() {};
        ~Teacher() {};
        void print(Person& person)
        {
            person.print();
        }    
    };
    #endif

    代码段3:主文件main.cpp
    #include<iostream>
    #include "person.h"
    #include "teacher.h"
    int main()
    {
        Person p(40, "lisan");
        Teacher teacher;
        teacher.print(p);
        system("pause");
        return 0;
    }

    注意:

    类的前向声明只能用于定义指针、引用、以及用于函数形参的指针和引用
    前向声明的类是不完全的类型,因为只进行了声明而没有定义
    前向声明的作用:

    在预处理时,不需要包含#include"xxx",相对节约编译时间
    方便的解决两种类类型互相使用的问题。
    4.单例模式
    单例模式是程序设计模式中最常用的模式之一,其主要思想是将类的构造函数声明为私有的防止被外部函数实例化,内部保存一个private static的类指针保存唯一的实例,实例的实现由一个public的类方法代劳,该方法返回单例类唯一的实例。
    注意:

    采用单例模式的对象在进程结束才被释放。
    关于单例模式的详细内容大家可以去看单例模式的知识。下面是一个典型的单例例子:

    #include<iostream>
    #include<string>
    using namespace std;

    class Singleton 
    {
    public:
        static Singleton* getInstance()
        {
            instance =  new Singleton();
            return instance;
        }
        ~Singleton() {};
    private:
        Singleton() {};
        static Singleton* instance;
    };

    下面看怎么在另一个类中使用单例模式实现成员函数的调用:

    class Singleton
    {
    public:
        static Singleton* getInstance()
        {
            if (instance == nullptr)
            {
                instance = new Singleton();
                return instance;
            }
            else
                return  instance;
        }
        static void print_instance()
        {
            cout<<name <<" " <<age <<endl;
        }
        ~Singleton() {};
    private:
        Singleton() {};
        static Singleton* instance;
        static int age;
        static string name;
    };

    int  Singleton::age = 20;
    string Singleton::name = "lisan";
    Singleton* Singleton::instance = nullptr;

    class A
    {

    public:
        void print_a()
        {
             Singleton::getInstance()->print_instance();
        }

    };
    int main()
    {
        A a;
        a.print_a();
        system("pause");
        return 0;
    }
     

    展开全文
  • 调用 另一个类中的1, 方法(方法区别于成员方法的标志就是有无static)homework05.Test52.randomNumber(100,20,8); //直接调用即可, 包名.类名.方法名();同一个包中可不写包名.1 packagehomework06;23 importhomework...

    调用  另一个类中的

    1, 方法(方法区别于成员方法的标志就是有无static)

    homework05.Test52.randomNumber(100,20,8);  //直接调用即可,  包名.类名.方法名();同一个包中可不写包名.

    1 packagehomework06;2

    3 importhomework05.Test52;4

    5 importjava.util.Arrays;6

    7 public classTest62 {8

    9

    10 //调用某个类中已经封装的成员变量时,创建类对象p--用p.setXxx()对其进行赋值--用p.getXxx()返回该成员变量11

    12

    13

    14 public static voidmain(String[] args) {15 Student p = newStudent(); //创建Student类对象16 p.setName("李江文"); //访问成员变量并赋值17 System.out.println(p.getName()); //调用并输出成员变量18 p.setAge(24);19 System.out.println(p.getAge());20 21 int[] arr = Test52.randomNumber(100, 20, 8); // 调用方法22 System.out.println(Arrays.toString(arr));23 }24 }

    2,成员方法

    homework05.Test60 a = new homework05.Test60;   //创建类对象,不同包需要加包名或者在开头导入类import homework05.Test60;

    int[ ] arr = a.randomNumber(100,20,8);                    //通过  a.randomNumber(100,20,8)   语句调用另一个类的成员方法

    System.out.println(Arrays.toString(arr));

    1 packagehomework06;

    2 importjava.util.Arrays;3 importhomework05.Test61;4

    5 //调用某个类中已经封装的成员变量时,创建类对象p--用p.setXxx()对其进行赋值--用p.getXxx()返回该成员变量6 7

    8

    9 public classTest59 {10 public static voidmain(String[] args) {11 Student p = newStudent();12 p.setName("lijiangwen");13 System.out.println(p.getName());14 p.setAge(24);15 System.out.println(p.getAge());16 Test61 a = newTest61(); //创建类对象以访问类成员17 int[] arr =a.randomNumber(100,20,8);18 System.out.println(Arrays.toString(arr));19 }20 }

    1 packagehomework05;2

    3 importjava.util.Arrays;4 importjava.util.Random;5

    6 public classTest61 {7

    8

    9 /*定义一个方法,返回一个随机数组,并打印.数组长度自定,数组元素随机范围自定,以后当需要产生一个随机数组的时候,10 可以调用 homework05--Test52--randomNumber(int max, int min, int arrAmount)11 */

    12 public static voidmain(String[] args) {13 //调用randomNumber方法,并返回一个数组

    14 Test61 a = newTest61();15 int[] arr = a.randomNumber(100, 5, 10);16 System.out.println(Arrays.toString(arr)); //Arrays.toString(数组名)直接打印一个数组

    17 }18

    19 //定义一个能产生随机数组的方法.20 //三个参数,随机数的最大值,最小值和数组的长度

    21 public int[] randomNumber(int max, int min, intarrAmount) {22 Random a = new Random(); //定义一个随机数产生器

    23 int[] s = new int[arrAmount]; //定义一个数组,长度由参数决定24 //将产生的随机数赋给数组

    25 for (int i = 0; i < s.length; i++) {26 //使用nextInt(max)语句接收产生的随机数,括号内表示随机数的范围是0到max

    27 int b =a.nextInt(max);28 //对随机数进行判断,并产生一个在[min,max]范围内的随机数

    29 if (b <=min) {30 s[i] = b + (max -min);31 } else{32 s[i] =b;33 }34 }35 return s; //返回随机数组

    36 }37 }38

    39 //在同一个项目project中可以调用已经定义的方法,在不同project中则不可以调用

    40 /*当需要调用randomNumber()时,分两种情况,41 1,在同一个包中调用时,无需在开头导入类Test52,可直接在主方法中使用Test52.randomNumber()方式调用42 2,而在不同的包中调用该方法时,则使用homework05.Test52.randomNumber()对该方法进行调用;43 */

    3,成员变量

    newClass a = new newClass();    //创建类对象,不同包则最好先导入类

    //    无private,未封装:

    a.name01 = " lijiangwen" ;  //  直接通过类对象a.name01来给成员变量赋值

    System.out.println(a.name01);

    //  有private,已封装

    a.setName01( "lijiangwen") ;    //对封装的成员变量就只能通过setXxx()来给成员变量赋值

    System.out.println(a.getName01());   //使用getName01()来调用成员变量

    1 packagehomework06;2 importjava.util.Arrays;3 importhomework05.Test61;4

    5 //调用某个类中已经封装的成员变量时,创建类对象p--用p.setXxx()对其进行赋值--用p.getXxx()返回该成员变量67

    8

    9 public classTest59 {10 public static voidmain(String[] args) {11 Student p = newStudent();12 p.setName("李江文");13 System.out.println(p.getName());14 p.setAge(24);15 System.out.println(p.getAge());16 p.weight = 120;17 System.out.println(p.weight);18 Test61 a = newTest61();19 int[] arr =a.randomNumber(100,20,8);20 System.out.println(Arrays.toString(arr));21 }22 }

    1 packagehomework06;2

    3 //调用其他类中未封装的成员变量时,创建类对象a--直接用a. name01的形式进行赋值,调用,不必用a.setXxx(),a.getXxx()

    4

    5 public class Student { //创建一个类Student

    6 privateString name;7 private int age; //定义成员变量,private修饰变量,设定权限,仅限同一类中可以对其进行操作

    8 intweight;9

    10 //构造一个方法,对成员变量name,age进行初始化

    11

    12 publicStudent() {13 } //无参数构造方法,系统自动初始化成员变量

    14

    15 public void Student(String name, int age) { //无返回(void可不写),有参数构造方法,成员变量为参数

    16 this.name = name; //使用this.变量名 = 变量名;语句进行初始化

    17 this.age =age;18

    19 }20

    21 //定义成员方法,setXxx(),getXxx(),

    22

    23 public voidsetName(String name) {24

    25 this.name =name;26 }27

    28 publicString getName() {29 returnname;30 }31

    32 public void setAge(intage) {33 this.age =age;34 }35

    36 public intgetAge() {37 returnage;38 }39

    40

    41 public static voidmain(String[] args) {42 Student p = newStudent();43 NewClass a = newNewClass();44

    45

    46 a.name01 ="李江文01";47 a.age01 = 25;48 p.setName(a.name01);49 System.out.println(p.getName());50 p.setAge(a.age01);51 System.out.println(p.getAge());52 int weight = 130;53 System.out.println(weight);54 }55 }

    展开全文
  • } 方法2:友元类 友元类就是在类A声明一个类B,那么就称类B是类A的友元类,这时类B的对象可以访问类A的一切成员,包括私有成员。如下所示: #include #include using namespace std; class A { public: friend ...

    一、一个类调用另一个类

    在继承之外,在C++中一个类成员函数调用另一个类成员的方法主要有:类的组合,友元类,类的前向声明,单例模式等,下面主要讲讲这4种方法的实现

    方法1:利用类的组合

    示例1

    这种用法的几个点:

    1. 若student类与data类分别定义在不同的头函数中,在student类中先包含data类
    2. 在student类中声明data类的对象
    3. 在student类的构造函数中初始化data类的对象。
      此示例的用法,有一个,大家要注意,若student类有多个构造函数,那么,就需要在student类的每一个构造函数中初始化data类的对象,
    #include <iostream>
    #include <cstring>
    #include <cstdlib>
    using namespace std;
    
    class data
    {
    private:
    	int year;
    	int month;
    	int day;
    public:
        data(int yy,int mm,int dd)
        {
            year=yy;
            month=mm;
            day=dd;
        }
        void display()
        {
            cout<<"birthday:"<<year<<"-"
                <<month<<"-"<<day<<endl;
    
        }
    };
    class student
    {
    private:
        string name;
        data birthday;
    public:
        student(string nn,int yy,int mm,int dd):birthday(yy, mm, dd)
        {
            name=nn;
        }
        void output()
        {
            cout<<"name:"<<name<<endl;
            birthday.display();
        }
    };
    int main()
    {
        student s("张三",2000,12,03);
        s.output();
    }
    
    
    

    示例2

    组合通俗来讲就是类B有类A的属性,如声明一个Person类,再声明一个Teacher类,Person类对象有年龄和姓名成员,而Teacher类对象成员也有年龄和姓名属性,所以我们可以将类Person的对象作为类Teacher的成员变量,那么就实现了Teacher类对象也有这两个属性。如下所示:

    #include<iostream>
    #include<string>
    using namespace std;
    
    class Person
    {
      public:
    	  Person(int _age, string _name) :age(_age), name(_name) {}
    	  ~Person() {};
    	void print() 
    	{
    		cout << name<<"	" << age  << endl;
    	}
    	private:
    		int age;
    	   string name;
    };
    class Teacher
    {
    public:
    	Teacher(Person* _person) :person(_person) {}
    	~Teacher() {};
    	void print()
    	{
    		this->person->print();
    	}
    	private:
    		Person* person;
    		
    };
    
    int main()
    {
    	Person p(40, "lisan");
    	Teacher teacher(&p);
    	teacher.print();
    	system("pause");
    	return 0;
    }
    
    

    方法2:友元类

    友元类就是在类A中声明一个类B,那么就称类B是类A的友元类,这时类B的对象可以访问类A的一切成员,包括私有成员。如下所示:

    #include<iostream>
    #include<string>
    using namespace std;
    
    class A
    {
    public:
    	friend class B;
    	A(int _age, string _name) :age(_age), name(_name) {}
    	~A() {};
    	void print_a()
    	{
    		cout << name << "	" << age << endl;
    	}
    private:
    	int age;
    	string name;
    };
    class B
    {
    public:
    	B() {};
    	~B() {};
    	void print_b(A& a)
    	{
    		a.print_a();
    	}
    };
    
    int main()
    {
    	A a(20,"name");
    	B b;
    	b.print_b(a);
    	system("pause");
    	return 0;
    }
    

    注意:

    友元类是单向的,即类B是类A的友元类,但类A不是类B的友元类
    友元类不能传递,即类B是类A的友元类,类C是类B的友元类,但类C不是类A的友元类

    方法3.前项声明

    使用前面两种方法,如果将两个类在不同的头文件中声明,则需要在第二个类中包含第一个类的头文件,但使用类的前向声明则不用使用#include"xxx",具体实现如下:

    代码段1:在person.h头文件

    #pragma once
    #ifndef _PERSON_H
    #define _PERSON_H
    #include <string>
    #include <iostream>
    class Person
    {
    public:
    	Person(int _age, std::string _name) :age(_age), name(_name) {}
    	~Person() {};
    	void print() const
    	{
    		std::cout << name << "	" << age << std::endl;
    	}
    private:
    	int age;
    	std::string name;
    };
    
    #endif
    

    代码段2:在teacher.h头文件中

    #pragma once
    #ifndef _TEACHER_H
    #define _TEACHER_H
    //#include "person.h"   //前两种方法
    
    class Person;  //类的前向声明
    class Teacher
    {
    public:
    	Teacher() {};
    	~Teacher() {};
    	void print(Person& person)
    	{
    		person.print();
    	}	
    };
    #endif
    
    代码段3:主文件main.cpp
    #include<iostream>
    #include "person.h"
    #include "teacher.h"
    int main()
    {
    	Person p(40, "lisan");
    	Teacher teacher;
    	teacher.print(p);
    	system("pause");
    	return 0;
    }
    

    注意:

    类的前向声明只能用于定义指针、引用、以及用于函数形参的指针和引用
    前向声明的类是不完全的类型,因为只进行了声明而没有定义
    前向声明的作用:

    在预处理时,不需要包含#include"xxx",相对节约编译时间
    方便的解决两种类类型互相使用的问题。

    方法4.单例模式

    单例模式是程序设计模式中最常用的模式之一,其主要思想是将类的构造函数声明为私有的防止被外部函数实例化,内部保存一个private static的类指针保存唯一的实例,实例的实现由一个public的类方法代劳,该方法返回单例类唯一的实例。
    注意:

    采用单例模式的对象在进程结束才被释放。
    关于单例模式的详细内容大家可以去看单例模式的知识。下面是一个典型的单例例子:

    #include<iostream>
    #include<string>
    using namespace std;
    
    class Singleton 
    {
    public:
    	static Singleton* getInstance()
    	{
    		instance =  new Singleton();
    		return instance;
    	}
    	~Singleton() {};
    private:
    	Singleton() {};
    	static Singleton* instance;
    };
    

    下面看怎么在另一个类中使用单例模式实现成员函数的调用:

    class Singleton
    {
    public:
    	static Singleton* getInstance()
    	{
    		if (instance == nullptr)
    		{
    			instance = new Singleton();
    			return instance;
    		}
    		else
    			return  instance;
    	}
    	static void print_instance()
    	{
    		cout<<name <<" " <<age <<endl;
    	}
    	~Singleton() {};
    private:
    	Singleton() {};
    	static Singleton* instance;
    	static int age;
    	static string name;
    };
    
    int  Singleton::age = 20;
    string Singleton::name = "lisan";
    Singleton* Singleton::instance = nullptr;
    
    class A
    {
    
    public:
    	void print_a()
    	{
    		 Singleton::getInstance()->print_instance();
    	}
    
    };
    int main()
    {
    	A a;
    	a.print_a();
    	system("pause");
        return 0;
    }
    
    展开全文
  • 继承之外,C++中一个类成员函数调用另一个类成员的方法主要有:的组合,友元的前向声明,单例模式等,下面主要讲讲这4种方法的实现 方法1:利用的组合 组合通俗来讲就是B有A的属性,如声明一个...
  • c++中类外访问一个类的私有成员

    千次阅读 2019-05-08 10:58:25
    正常来说,类外无法访问类内的private成员只能通过类内成员访问private成员在类外,无论是通过类指针还是类对象都无法直接访问类的private成员 C++类的私友成员是不能通指针操作的。 #include <...
  • 【单选题】的定义必须包含以下种符号之间?【多选题】下面对于构造方法的描述,正确有哪些?(多选)【填空题】Choose an acceptable verb form from the two given in brackets according to the standard of form...
  • 如何C#定义一个类

    千次阅读 2020-07-28 15:39:45
    定义了一个类后就可以项目中能访问到该的位置实例化该,默认情况下的声明为内部的,即只有当前代码才能访问它,可使用internal关键字来显式指出这一点,但是没有必要 internal class MyClass { //class ...
  • C++——的静态成员

    千次阅读 2018-09-03 16:04:20
    、声明静态成员 ...2、的静态成员存在于任何对象之外,对象不包含任何与静态数据成员有关的数据,静态数据成员被所有该类型的对象共享。 3、静态成员函数也不与任何对象绑定一起,它们不包...
  • 浅谈C++类中6个成员函数

    千次阅读 多人点赞 2021-03-18 15:45:13
    构造函数是一个特殊的成员函数,名字与类名相同且不能有返回值,创建类型时由编译器自动调用,对象的生命周期内只调用一次。**主要任务是初始化对象。 ↓下面一个简单的构造函数(全缺省): 主函数初始化时...
  • C++ 类中数据成员分布详解

    千次阅读 2018-12-22 23:39:13
    我们都知道类中包含着数据成员,但是数据成员在内存是怎样分布的呢?继承之后数据又是怎样布局的呢?下面对这些问题进行整理。的空间分布是编译器编译的结果,不同的编译器有可能会不一样,但是原理是一样的。 ...
  • 共回答了21个问题采纳率:81%选择错误的。A 接口中只能包含抽象方法和常量这个是正确的下面给你说一下抽象和接口的区别:抽象由abstract...B 一个类可以实现多个接口这个是正确的,java 支持多实现 但是不支...
  • 展开全部public class Student {//1、定义成员变量private String no;//学号private String name;//姓名private String sex;//性别private String age;//年龄private float score;//成绩//2、通过构造方法初始化成...
  • static成员必须在类外初始化

    千次阅读 2017-11-30 21:01:10
    为什么静态成员不能在类内初始化在C++,类的静态成员(static member)必须在类内声明,在类外初始化,像下面这样 class A { private: static int count ; // 类内声明 };int A::count = 0 ; // 类外初始化,...
  • 原因如下:1、构造函数不能被声明为const函数,因此当我们创建一个类的const对象时,直到构造函数完成初始化的过程,对象才真正取得其“常量”的属性,因此,构造函数const对象的构造过程可以向其写值;...
  • Java -- 成员内部不能含有static成员(汇总)

    千次阅读 多人点赞 2020-11-15 14:14:51
    文章目录1、为什么内部类中有static成员时内部也必须声明为static2、JVM的加载规则 :3、成员内部类中为什么不能有静态方法和属性4、静态内部(public static class)和普通内部(public class)的区别5、Java...
  • c++类成员变量初始化详解

    千次阅读 2022-04-15 10:08:24
    1.初始化顺序 当初始化的时候,会调用其构造函数并进行初始化。...第种方式是在成员变量声明时初始化。可以看如下示例。 class D { int a = 10; }; 声明变量a的时候即给其初始化为10。不过注意这种写法是c++1
  • 【单选题】关于 Java 语言叙述错误的是( )。【判断题】类中 static 修饰的变量或方法,可以使用类名或对象的...【判断题】Java 的每个都至少有一个构造方法,一个类中如果没有定义构造方法,系统会自动为这个创建...
  • 设计一个只能创建一个唯一实例的——单例模式 1. 背景  老师布置了一个思考题:设计一个只能创建一个唯一实例的。让我们只要想一下思路即可。自己的第一反应就是设计模式的单例模式。自己百度了一下单例...
  • 一般而言,类中的数据成员在定义的时候是不能初始化的。 这是一个可以值得探讨的话题,每个人的解释都不一样,大部分人都认为这是编译语法的规定,那么有没有考虑为什么会有这个规定呢?  个人认为可能的原因有: ...
  • 2、为什么一个java源文件中只能一个public?每个编译单元(文件)都只能一个public,这表示,每个编译单元都有单一的公共接口,用public来表现。该接口可以按要求包含众多的支持包访问权限的。public...
  • 成员函数

    千次阅读 2020-11-12 11:42:55
    函数的定义一般在类外面,也可以直接在类内部定义。前者与普通函数不同的是,实现成员函数时要指明类的名称,具体形式为: 返回值类型 类名::函数成员名(参数表){函数体}; 而后者一般为一些短小的函数(5行以内)...
  • C++中类的(static)静态成员变量与(static)静态成员函数

    万次阅读 多人点赞 2018-08-04 11:27:28
    C++的类中,也有静态成员变量同时还有静态成员函数,先来看看C++静态成员变量与静态成员函数的语法: #include &lt;iostream&gt; #include &lt;string&gt; using namespace std; class ...
  • 为什么static成员变量一定要在类外初始化?

    万次阅读 多人点赞 2018-08-17 10:07:01
    在C++,类的静态成员(static member)必须在类内声明,在类外初始化,像下面这样。 class A { private: static int count ; // 类内声明 }; // 类外定义并初始化,不必再加static关键字 int A::count = 0 ; ...
  • 为啥静态函数只能调用静态成员

    千次阅读 多人点赞 2020-06-25 23:04:54
    在类中,静态成员可以实现多对象之间的数据共享,并且使用静态数据成员还不会破坏隐藏的原则,即保证了安全性。因此,静态成员是类的所有对象共享的成员,而不是某个对象的成员。 使用静态数据成员可以节省...
  • C++ 成员变量

    千次阅读 2022-02-25 09:01:50
    C++ 成员变量
  • 定义一个类只能创建一个对象

    千次阅读 2014-10-13 08:30:38
    有时我们的程序需要定义一个类,这个类只能创建一个youxiaosh

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 421,693
精华内容 168,677
热门标签
关键字:

在类中下面哪一个成员只能在