精华内容
下载资源
问答
  • 文章目录1.的数据成员2.类的成员函数3.... 如果一个类具有多个同一类型的数据成员, 则这些成员可以在一个成员声明中指定。 class Cube //Cube表示立方体 { … //其他成员 long color; //数据成员 d...

    1.类的数据成员

    (1)在类中声明数据成员
    正如我们所见, 类的数据成员的声明类似于普通变量的声明。 如果一个类具有多个同一类型的数据成员, 则这些成员可以在一个成员声明中指定。

    class Cube  //Cube类表示立方体
    {//其他成员
    	long color; //数据成员
    	double x,y,z,side; //数据成员
    };
    
    • 类的数据成员可以是基本类型、 数组、 指针、 引用、 共用体、 枚举类型、 void指针、 const限定等数据类型。 例如:
    class ADT  //类成员数据类型
    {//成员函数
    	long color;
    	double x,y,z,side; //基本类型
    	int a[10]; //数组
    	char *s; //指针
    	char &r; //引用
    	void *p; //void指针
    };
    
    • 类的数据成员还可以是成员对象(member object) , 即类类型或结构体类型的对象。 若类A中嵌入了类B的对象, 称这个对象为子对象(subobject) 。 例如: 类Line嵌入了类Point的子对象start、 end。
    class Point  //Point类表示点
    {
    	public:
    		void set(int a,int b);
    		int x,y;
    };
    class Line  //Line类表示线
    {
    	public:
    		void set(Point a,Point b);
    		Point start, end; //成员对象
    };
    

    (2)在类中定义或声明数据类型

    • 除了定义数据成员和成员函数之外, 类还可以定义自己的局部类型,并且使用类型别名来简化。
    • 在类中定义或声明的数据类型的作用域是类内部, 因此, 它们不能在类外部使用。
    • 在类定义中, 可以定义结构体和共用体类型、 嵌套的类定义, 声明枚举类型
      eg:
    class ADT  //类定义
    {
    	struct Point  //定义结构体
    	{ 
    		int x,y; 
    	};
    	union UData  //定义共用体
    	{
    		Point p; 
    		long color; 
    	};
    	enum COLORS {RED,GREEN,BLUE,BLACK,WHITE }; //定义枚举类型
    	class Nested  //嵌套类定义
    	{//成员函数
    		Point start; //数据成员
    		UData end; //数据成员
    		COLORS color; //数据成员
    	};
    	typedef Point* LPPOINT; //声明类型别名
    	… //成员函数
    	… //数据成员
    }; //类定义结束
    

    2.类的成员函数

    (1) 在类的外部定义成员函数

    • 如果成员函数仅有声明在类定义中, 则在类外部必须有它的实现,其一般形式为:
    返回类型 类名::函数名(形式参数列表)
    {
    	函数体
    }
    

    eg:

    class Data//Data类定义
    {
    	public:
    		void set(int d);//成员函数原型声明
    		int get()//成员函数定义
    		{	
    			return data;
    		}//get函数定义结束
    	private:
    		int data;//数据成员
    };//Data类定义结束
    
    void Data::set(int d)//set函数所属于类Data,//成员函数的外部定义, 使用 Data:: 限定
    {
    	data=d;//访问类的数据成员
    }
    void set(int d)//全局普通函数
    {
    	,,,//函数体
    }
    
    说明:
    (1) (::) 是作用域限定符(field qualifed,常称之为域作用符)。 如果在作用域限定
    符的前面没有类名, 或者函数前面既无类名又无作用域限定符, 例如:
    ::set(10)set(10)
    则表示set函数不属于任何类, 这个函数不是成员函数, 而是全局的普通函数。 
    此时的(::) 不是类作用域限定符的含义, 而是命名空间域限定符的含义。
    
    (2) 在成员函数中可以访问这个类的任何成员, 无论它是公有的或是私有的, 
    是类内部声明的还是类外部定义的。
    
    (3) 虽然成员函数在类的外部定义, 但在调用成员函数时会根据在类中声明的函数原型找到函数
    的定义(即函数代码) , 从而执行该函数。 因此类的成员函数原型声明必须出现在成员函数定义之前,
    否则编译时会出错。
    
    重点:(4) 在类的内部声明成员函数, 而在类的外部定义成员函数, 这是一个良好的编程习惯。 因为不
    仅可以减少类体的长度, 使类体结构清晰, 便于阅读, 而且有助于类的接口和实现分离。
    ►(5) 如果一个成员函数, 其函数体不太复杂, 只有45行时, 一般可在类体中定义
    
    
    

    (2)内联成员函数

    • 类的成员函数可以指定为inline, 即内联函数。
    • 默认情况下, 在类体中定义的成员函数若不包括循环等控制结构,符合内联函数要求时, C++会自动将它们作为内联函数处理(隐式inline) 。
    • 也可以显式地将成员函数声明为inline。 例如
    
    class Data//Data类定义
    {
    	int getx()//内联成员函数
    	{
    		return x;
    	}
    	inline int gety()//显式指定内联成员函数
    	{
    		return y;
    	}
    	inline void setxy(int _x, int _y);//显式指定内联成员函数
    	void display();
    	int x,y;
    };
    inline void Data::setxy(int _x,int _y)//内联成员函数
    {
    {
    	x=_x;
    	y=_y;
    }
    void Data::display()//非内联成员函数
    {
    	...//函数体
    }
    
    • 判断成员函数是否是内联的, 有以下几条:
      ① 符合内联函数要求;
      ② 符合①的条件, 并且在类体中定义, 自动成为内联的;
      ③ 符合①的条件, 在类体显式指明inline, 或在外部定义时显式指明inline, 或者同时显式指明, 则函数是内联的;
      ④ 在类外部定义, 并且既没有在类体, 也没有在外部定义时显式指明inline, 则函数不是内联的。

    3.成员函数重载及默认参数

    • 可以对成员函数重载或使用默认参数。 例如:
    class MAX
    {
    	int Max(int x, int y)//函数名一样,类一样,就是函数重载
    	{
    	}
    		return x>y?x:y;
    	int Max()//重载Max
    		return Max(Max(a,b),Max(c,d));
    	int Set(int i=1,int j=1,int k=3.int l=4)//默认参数
    	{
    		a=i,b=i,c=k,d=l;
    	} 
    	int a,b,c,d;
    }
    
    需要注意, 声明成员函数的多个重载版本或指定成员函数的默认参数, 只能在类内部中进行。
    
    因为类定义中的声明先于成员函数的外部实现, 根据重载或默认参数函数的要求, 必须在第
    1次出现函数声明或定义时就明确函数是否重载或有默认参数。先声明,再定义
    

    4.成员函数的存储方式

    • 用类实例化一个对象时, 系统会为每一个对象分配存储空问。 如果一个类包括了数据成员和成员函数, 则要分别为数据和函数的代码分配存储空间。

    • 通常, C++会为每个对象的数据成员分配各自独立的存储空间, 像结构体成员那样

    • 那么在类中的成员函数是否会如图所示那样也分配各自独立的存储空间呢?
      在这里插入图片描述

    • 由于不论调用哪一个对象的函数代码, 实际调用的都是同样内容的代码。 因此, 若像上图那样存放相同代码的多份副本, 既浪费空间又无必要。

    • 实际上, 成员函数代码只有公用的一段存储空间, 调用不同对象的成员函数时都是执行同一段函数代码。
      在这里插入图片描述

    • 类的数据成员与类的成员函数的关系:
      成员函数从属于类;
      从存储空间来说,成员函数与类是不依赖的,即:类的数据成员和成员函数是分开来存储的;

    • 例如定义了一个类

    
    class Time//Time类
    {
    	int h,m,s;//数据成员
    	void settime(int a,int b,int c)//成员函数
    	{
    		h=a.m=b,s=c;
    	}
    };
    
    sizeof(Time)的值是12。 显然, Time类的存储空间长度只取决于数据成员h、 m、 s所占的空间, 
    而与成员函数settime无关。 C++把成员函数的代码存储在对象空间之外的地方。
    

    5.类的声明

    • 一旦遇到类体后面的右大括号, 类的定义就结束了。
    • 在一个给定的源文件中, 一个类只能被定义一次。
    • 通常将类的定义放在头文件中, 这样可以保证在每个使用该类的文件都以同样的方式定义类
    • 可以只声明一个类而不定义它:
    class Point; //Point类声明, 非Point类定义, 因为没有类体
    
    • 这个声明, 称为前向声明(forward declaration) , 表示在程序中引入了Point类类型。

    • 在声明之后、 定义之前, 类Point是一个不完全类型, 即已知Point是一个类, 但不知道它包含哪些成员。 因此不能定义该类型的对象,只能用于定义指向该类型的指针及引用, 或者用于声明(而不是定义) 使用该类型作为形参类型或返回类型的函数。

    • 在创建类的对象之前, 必须完整地定义该类。 这样, 编译器就会给类的对象准备相应的存储空间。

    • 同样地, 在使用引用或指针访问类的成员之前, 必须己经定义类。

    • 类不能具有自身类型的数据成员。 然而, 只要类名一经出现就可以认为该类己声明。 因此, 类的数据成员可以是指向自身类型的指针或引用
      eg:

    class Point; //Point类声明, 非Point类定义, 因为没有类体
    class Line {
    	Point a; //错误, 不能使用仅有类声明而没有类定义的类定义数据对象
    	
    	Point *pp, &rp; //正确, 只有类声明, 即可用它定义该类的指针或引用
    	
    	Line b; //错误, 类不能具有自身类型的数据成员
    	
    	Line *pl, &rl; //正确, 类可以有指向自身类型的指针或引用的数据成员
    };
    
    展开全文
  • 类的成员

    2020-08-17 17:19:27
    2.类的成员 1. 属性(field) 用来描述具体某个对象的特征。描述的是对象的状态信息,通常以变量的形式进行定义。 语法格式:  权限修饰符 [特征修饰符] 数据类型 属性名字[ = 值]; 例如: public class Pe

    1.Java语言的基本元素

    类实际上在现实当中是不存在的,是一个抽象的概念,是一个模板。类的本质上现实世界当中某些事物具有共同特征,将这些共同特征提取出来形成的概念就是一个“类”。在Java的世界中,“万物皆为对象”。

    对象是实际存在的个体(真实存在的个体),是类的实例化。

    2.类的成员

    1. 属性(field)
    用来描述具体某个对象的特征。描述的是对象的状态信息,通常以变量的形式进行定义。
    语法格式:
      权限修饰符 [特征修饰符] 数据类型 属性名字[ = 值];
    例如:

    public class Person {
        public String name;//成员变量
        public int age;
        public String sex;
    }
    

    变量通常分为成员变量和局部变量。
    在类体中,方法体之外定义的变量称为“成员变量”

    • 成员变量定义在类体中,在整个类中都可以被访问。
    • 成员变量分为类变量和实例变量,实例变量存在于对象所在的堆内存中
      成员变量有默认初始化值
    • 成员变量的权限修饰符可根据需要,选择任意一个
    • 创建对象后才能访问的变量称为实例变量

    定义在方法内,代码块内的变量称为局部变量

    • 局部变量定义在局部范围内
    • 局部变量存在于栈内存中
    • 作用范围结束,变量空间自动释放
    • 局部变量无默认值,每次必须显示初始化
    • 局部变量声明时一般不指定权限修饰符
      在这里插入图片描述
      在这里插入图片描述

    2. 方法(method)
    描述的是对象的动作信息,为定义在类中的具特定功能的一段独立的程序。
    语法格式:
    权限修饰符 [特征修饰符] 返回值类型 方法名字 (参数)[抛出的异常]{
      方法体
    }

    • 方法是类或对象行为特征的抽象,用来完成某个功能操作。在某些语言中也称为函数或过程。
    • 将功能封装为方法的目的是,可以实现代码重用,简化代码
    • Java里的方法不能独立存在,所有的方法必须定义在类里。
    public class Person {
        //属性和方法--静态描述特点
        //必要的组成部分
        //  修饰符   数据类型   属性姓名[=值]
        //权限修饰符 [特征修饰符] 数据类型 属性名字
        public String name;//全局变量
        public int age;
        public String sex;
    
        //方法--描述可以做什么事情(动作)
        //权限修饰符 [特征修饰符] 返回值类型 ([参数列表]){方法体}
        //1、无参数无返回值
        //2、无参数有返回值
        //3、有参数无返回值
        //4、有参数有返回值
    
        //无参数无返回值
        //设计一个方法  用来描述人类可以做吃饭这件事
        public void eat(){
            System.out.println("吃了一碗大米饭");
        }
        //无参数有返回值
        //设计一个方法  用来告诉别人我的名字
        public String tellName(){
            System.out.println("你们问我叫什么名字呀?勉强告诉你们一下");
            return "张三";
        }
        //有参数无返回值
        //设计一个新的吃饭方法
        public void chiFan(int count,String something){
            System.out.println("吃了"+count+"碗"+something);
        }
        //有参数有返回值
        //设计一个方法 买饮料  1.需不需要提供条件   2.需不需要给别人留下什么结果
        //需要提供条件   钱     需要返回值   饮料
        public String buyDrink(int money){
            if(money>5){
                return "红牛";
            }
            else{
                return "矿泉水";
            }
        }
    }
    

    方法的重载(overload)
    概念:在同一个类中,允许存在一个以上的同名方法,只要它们的参数个数或者参数类型不同即可。
    重载的特点:
    与返回值类型无关,只看参数列表,且参数列表必须不同。(参数个数或参数类型)。调用时,根据方法参数列表的不同来区别。

    参数列表的不同体现在哪里?

    • 参数的个数
    • 参数的leixing
    • 参数的顺序
    public class TestOverload {
    
        //方法重载
        public void test(){
            System.out.println("执行了test方法中没有带参数");
        }
        public void test(boolean b){
            System.out.println("执行了test方法中带boolean参数"+b);
        }
        public void test(int i){
            System.out.println("执行了test方法中带int参数"+i);
        }
        public void test(char c){
            System.out.println("执行了test方法中带char参数"+c);
        }
        public void test(String s){
            System.out.println("执行了test方法中带String参数"+s);
        }
    
        public static void main(String[] args){
            //创建对象
            TestOverload to = new TestOverload();
            
            //通过对象.方法名字  调用方法  可以直接通过方法名字定位方法
            //如果方法名字一直  通过方法的参数列表类型来定位
            //通过对象调用方法 方法执行一遍
            to.test('a');//方法参数传递  类型之间的转换问题
            //当没有char类型的方法时,会找一个参数类型可以自动转换的int类型方法
    
            System.out.println(to);//TestOverload@34e45f-->hashCode码
        }
    }
    

    可变个数的参数

    public class Test {
        //JDK1.5版本之后 出现的一个新的写法-->动态参数列表
        //不能与数组类型的方法构成重载,因为本质上是一样的
        public void test(int... x){//本质上是数组
            System.out.println("执行了test方法携带的动态列表");
            for(int i=0;i<x.length;i++){
                System.out.println(x[i]);
            }
        }
        public void test(int[]...x){
            System.out.println();
        }
    
    
        public static void main(String[] args){
            //创建对象
            Test t = new Test();
            t.test(1,2,3,4,5);
            
        }
    }
    

    方法参数返回值问题
    Java的实参值如何传入方法呢?
    Java里方法的参数传递方式只有一种:值传递。 即将实际参数值的副本(传入方法内,而参数本身不受影响。

    • 形参是基本数据类型:将实参基本数据类型变量的“数据值”传递给形参
    • 形参是引用数据类型:将实参引用数据类型变量的“地址值”传递给形参
    public class Test {
        public int changeNum(int x){//将void变为int类型的
            System.out.println("方法执行开始:"+x);//1
            x = 10;
            System.out.println("方法执行最终:"+x);//10
            return x;//返回值  将x临时的变量空间内的值(值或引用)返回出来
        }
    
        public void changeArray(int[] x){
            System.out.println("方法执行开始:"+x[0]);//1
            x[0] = 10;
            System.out.println("方法执行最终:"+x[0]);//10
        }
        //每一个类中不是必须包含主方法的
        //主方法不属于任何一个类,主方法主语虚拟机
        public static void main(String[] args){
            //创建一个对象--前提 有一个类模型
            //加载类模板的过程
            Test t = new Test();//堆内存中开辟空间
            int a = 1;
            a = t.changeNum(1);//需要一个int的条件  int x = a;
            //调用方法  让方法执行一遍
            //1.方法存在哪里? 堆内存的对象空间内
            //2.方法在哪里执行?  栈内存中开辟一块临时的方法执行空间
            System.out.println("方法执行完毕,main方法中a的值:"+a);//1
            // 临时开辟的执行changeNum方法的空间就没了   a的值没有改变只是被用了
    
            System.out.println("++++++++++++++++++++++++++++++++++++++");
            //加载类模板的过程
            int[] b = new int[]{1,2,3};
            t.changeArray(b);
            //方法存在堆内存的对象空间里 方法执行在栈内存中的临时空间里
            //调用方法值将b的值传递给了x  int[] x = b; 传递过来的就是一个引用
            System.out.println("方法执行完毕,main方法中b数组的第一个值:"+b[0]);//10
    
            /**形参和实参
             * 形参可以理解为是方法执行时的临时变量空间 x
             * 实参可以理解为是方法调用时传递进去的参数 a
             *方法调用时会将实参的内容传递给形参
             * 如果内容是基本类型  传递的是值           形参改变  实参不变
             * 如果内容是引用类型  传递的是引用(地址)   形参改变  实参跟着改变
             */
        }
    }
    

    方法参数及返回值传递(基本类型)
    在这里插入图片描述
    方法参数及返回值传递(引用类型)
    在这里插入图片描述

    3. 构造方法(构造器)
    构造方法的作用:构建(构造)当前类的对象;给对象进行初始化
    语法格式:
    权限修饰符 与类名一致的方法名 (参数列表) [抛出异常]{
      语句;
    }

    public class Animal {
    	private int legs;
    	// 构造器
    	public Animal() {
    		legs = 4;
    	} 
    	public void setLegs(int i) {
    		legs = i; 
    	}
    	public int getLegs() {
    		return legs; 
    	}
    }
    
    

    创建Animal类的实例:Animal a = new Animal();调用构造方法,将legs初始化为4。
    根据参数不同,构造器可以分为如下两类:

    • 隐式无参数的构造方法(系统默认提供)
    • 显式定义一个或多个构造方法(无参、有参)

    注意

    • 一旦显式定义了构造方法,则系统不再提供默认构造方法
    • 一个类可以创建多个重载的构造方法

    构造方法的重载

    public class Person{
    public Person(String name, int age, Date d) {this(name,age);}
    public Person(String name, int age) {}
    public Person(String name, Date d) {}
    public Person(){}
    }
    
    

    4. 块
    作用:跟普通方法一样 做事情
    语法格式:
    {
      java语句;
    }
    可以认为块是一个没有修饰符,没有参数,没有返回值,没有名字的特殊方法。
    用法:

    • 块需要调用才能执行,但是不需要我们自己调用
    • 每一次调用构造方法之前,会自动调用块

    3.this关键字

    this是什么?

    • 在方法内部使用,即这个方法所属对象的引用;
    • 在构造器内部使用,表示该构造器正在初始化的对象。

    this 可以调用类的属性、方法和构造器

    什么时候使用this关键字呢?

    • 当在方法内需要用到调用该方法的对象时,就用this。
      具体的:我们可以用this来区分属性和局部变量。比如:this.name = name;
    public class Person(){
    	String name;
    	int age;
    	
    	public Person(){}
    	public Person(String name, int age){
    		this.name = name;
    		this,age = age;
    	}
    	public void talk(){
    		System.out.println("Person类中的说话方法");
    		this.study();
    	}
    	public void study(){
    		System.out.println("Person类中的学习方法");
    	}
    	public void display(){
    		System.out.println(this.name + "今年" + this.age + "岁");
    	}
    }
    
    1. 在任意方法或构造器内,如果使用当前类的成员变量或成员方法可以在其前面添加this,增强程序的阅读性。不过,通常我们都习惯省略this。
    2. 当形参与成员变量同名时,如果在方法内或构造器内需要使用成员变量,必须添加this来表明该变量是类的成员变量。
    3. 使用this访问属性和方法时,如果在本类中未找到,会从父类中查找。
    4. his可以作为一个类中构造器相互调用的特殊格式。
    展开全文
  • 枚举类型成员的方法

    2019-06-26 14:54:02
    用户可以将一个枚举类型看作是枚举类型的一个实例,它继承于java.lang.Enum,当定义一个枚举类型时,每一个枚举类型成员都可以看作是枚举类型的一个实例,这些枚举类型成员都默认被final、public、static修饰,...

    枚举类型较传统定义常量的方式,除了具有参数类型检测的优势之外,还具有其他方面的优势。
    用户可以将一个枚举类型看作是枚举类型的一个实例,它继承于java.lang.Enum类,当定义一个枚举类型时,每一个枚举类型成员都可以看作是枚举类型的一个实例,这些枚举类型成员都默认被final、public、static修饰,所以当使用枚举类型成员时直接使用枚举类型名称调用枚举类型成员即可。
    由于枚举类型对象继承于java.lang.Enum类,所以该类中一些操作枚举类型的方法都可以应用到枚举类型中。下面将列举了枚举类型中的常用方法。
    方法名称 具体含义 使用方法
    values() 该方法可以将枚举类型成员以数组的形式返回 枚举类型名称.values()
    valueOf() 该方法可以实现将普通字符串转换为枚举实例 枚举类型名称.valueOf(“a”)
    compareTo() 该方法用于比较两个枚举对象在定义时的顺序 枚举对象.compareTo()
    ordinal() 该方法用于得到枚举成员的位置索引 枚举对象.ordinal()

    (1)、values()
    枚举类型实例包含一个values()方法,该方法将枚举类型的成员变量实例以数组的形式返回,也可以通过该方法获取枚举类型的成员。
    例:在项目中创建ShowEnum类,在该类中使用枚举类型中的values()方法获取枚举类型中的成员变量。
    在这里插入图片描述
    使用枚举类型中的values()方法获取枚举类型中的成员变量,运行结果:
    在这里插入图片描述
    例子中,由于values()方法将枚举类型的成员以数组的形式返回,所以根据该数组的长度进行循环操作,然后将该数组中的值返回。
    (2)、valueOf()与compareTo()
    枚举类型中静态方法valueOf()可以将普通字符串转换为枚举类型,而compareTo()方法用于比较两个枚举类型对象定义时的顺序。
    例:在项目中创建EnumMethodTest类,在该类中使用枚举类型中的valueOf()与compareTo()方法。
    在这里插入图片描述
    使用compareTo()方法比较两个枚举类型成员定义的顺序,运行结果:
    在这里插入图片描述
    调用compareTo()方法返回的结果,正值代表方法中参数在调用该方法的枚举对象位置之前;0代表两个互相比较的枚举成员的位置相同;负值代表方法中参数在调用该方法的枚举对象位置之后。

    展开全文
  • i. 定义具有两个私有数据成员,分别表示字符串存储地址(char*类型)和长度(int类型)。实现字符串String构造函数、析构函数、拷贝构造函数、赋值运算。 ii. 实现运算符重载:String + String、String + char * ...

    2、实现一个自定义的字符串类String。

    i. 定义具有两个私有数据成员,分别表示字符串的存储地址(char*类型)和长度(int类型)。实现字符串类String的构造函数、析构函数、拷贝构造函数、赋值运算。
    ii. 实现运算符重载:String + String、String + char *
    iii. 重载运算符 << 和 >> ,实现字符串的输入和输出。
    iv. 在main函数写一段简单的使用该字符类(包含上述运算)的测试程序

    test.cpp

    #include"string.h"
    #include<iostream>
    using namespace std;
    int main()
    {
    	String s1, s2;
    	s1 = "chenhaoran";
    	s2 = "zhangchao";
    	cout << s1<<endl;
    	String s3(s2);
    	cout << s3<<endl;
    	String s4 = s3;
    	cout << s4 << endl;
    	//cout << s4 + s2 << endl;
    	String s6 = s4 + s2;
    	s1 = s4 + s2;//这不是调用复制构造函数
    	cout << s6 << endl;
    	return 0;
    }
    

    string.h

    #pragma once
    #include<ostream>
    #include<istream>
    using namespace std;
    class String {
    private:
    	char *_str;
    	int _size;
    public:
    	String();
    	~String();
    	String(const String &s);
    	//friend String operator +(const String &temp1, const String &temp2);
    	//friend String operator +(const String &temp1, const char * temp2);
    	String operator+(const String &temp);
    	String operator+(const char *temp);
    	//String &operator =(String temp);
    	String &operator =(const char *temp);
    	friend ostream &operator<< (ostream &out, String &temp);//这里为什么是取地址符
    	friend istream &operator>>(istream &in,String &temp);
    
    };
    
    

    string.cpp

    #include"string.h"
    #include<string.h>
    #include<iostream>
    using namespace std;
    String::String()
    {
    	_str = new char[20];
    	_size = 0;
    }
    String::~String()
    {
    	if (this->_str != NULL)
    	{
    		delete[] this->_str;	
    		this->_str = NULL;
    		this->_size = 0;
    	}
    }
    String::String(const String &s)
    {
    	int len = strlen(s._str);
    	_str = new char[len + 20];
    	strcpy(_str, s._str);
    	_size = s._size;
    }
    String String::operator+(const String &temp)
    {
    	String *p=new String();
    	p->_str = new char[strlen(this->_str) + strlen(temp._str) + 1];
    	strcpy(p->_str, this->_str);
    	strcat(p->_str, temp._str);
    	return *p;
    }
    /*
    String operator +(const String &temp1,const String &temp2)
    {
    	//String temp(temp1);
    	String temp;
    	strcpy(temp._str, temp1._str);
    		//strcat(temp._str, temp1._str);
    	temp._size += temp1._size;
    	strcat(temp._str, temp2._str);
    	temp._size += temp2._size;
    	return temp;
    }
    String operator +(const String &temp1,const char *temp2)
    {
    	String temp(temp1);
    	int len = strlen(temp2);
    	strcat(temp._str, temp2);
    	temp._size += len;
    	return temp;
    
    }
    */
    //String &String::operator=(String temp)
    //{
    	
    //	strcpy(this->_str, temp._str);
    //	this->_size = temp._size;
    //	return *this;
    //}
    String &String::operator=(const char *temp)
    {
    	memset(this, '\0', this->_size);
    	strcpy(this->_str, temp);
    	this->_size = strlen(temp);
    	return *this;
    }
    ostream &operator<< (ostream &out,String &temp)
    {
    	out << temp._str;
    	return out;
    }
    istream &operator>> (istream &in,String &temp)
    {
    	in >> temp._size;
    	return in;
    }
    
    展开全文
  • 在c++primer中看到这么句话“因为只有当定义体完成后才能定义,因此不能具有自身类型的数据成员。然而,只要名义出现就可以认为该已经声明,因此,的数据成员可以是指向自身类型的指针或引用”java中...
  • 系列文章目录 重新复习c++,所以把书中的重点内容...const可以约束基本类型的数据成员为常数据成员。 有两种方式对常数据成员进行初始化 1、在构造函数中直接用常量进行初始化,这样每个对象建立的常数据成员都有相同的
  • 对于具有类类型的成员,则会调用该成员所属类自身的默认构造函数实现初始化。 内置类型成员的初值依赖于对象如何定义,如果对象在全局作用域中定义或定义为静态局部对象,则这些成员将被初始化为0。如果...
  • 切记:自己定义的类千万别和系统中windows.h或者其他冲突,否则不显示具体错误。排查较为麻烦。 在上一篇博客中介绍了如何使用C++连接到数据库C++连接MySQL数据库 但是在我使用时候发生了一个奇怪错误,如下...
  • 类类型

    2020-05-15 21:28:12
    Class ClassName 关键字Class用于声明一个类类型 { 数据成员 函数成员 }; 类内: 在类声明之内,类外: 在类声明之外。 c++中通过设置成员的访问控制属性来实现对类成员的访问控制,这些属性控制有:public ...
  • C++语言中,对于一个枚举类型(enum),其成员值在所属枚举类型的声明作用域内是不可重复的。...6和.net系列语言中,两个不同的Enum类型可以具有相同的成员,在使用时只需加上Enum类型名称。目
  • C++语言中,对于一个枚举类型(enum),其成员值在所属枚举类型的声明作用域内是不...而在Visual Basic 6和.net系列语言中,两个不同的Enum类型可以具有相同的成员,在使用时只需加上Enum类型名称。目前就是要在
  • // 定义两个具有完全相同成员的类 class A { public String S = "A"; public int Val = 1; private double DVal = 10.1; } class B { public String S = "B"; public int Val = 2; private double DVal ...
  • C++类的特殊数据成员

    2016-03-30 16:03:52
    在构造函数一节的介绍中, 我们已经提到了在C++中有几特殊的数据成员不能... const 类型的数据成员具有只读属性, 在构造函数内进行初始化是不允许的, 例如以下代码: #include using namespace std; class A
  • c++静态成员

    2016-04-28 17:07:00
    静态成员和非静态成员的区别: 静态成员用static修饰,类的静态成员属于本身,而不属于类的某个具体对象,静态成员类的所有对象共享,因此某个对象对静态成员...静态数据成员的类型可以是它所属类的类...
  • “error 对成员xx1请求出现在XX2中,但后者具有非类类型 ” 出现问题原因要么是有跟结构体、union、等重名变量,要么是下标、“.”或“->”错误导致 重名情况往往只出现在某一个函数中,昨晚一个师弟...
  • 类的静态成员的用法

    2017-09-19 21:29:20
    静态数据成员存放一般在private中 ,它具有静态生存期,表示 为 数据类型 类名::静态数据名 所能解决问题: 可以计算种类对象数量 代码: class A {  static int i; }; int A::i=0;  注: 如果你...
  • 用于说明类的成员的访问权限。这种叫公有。在一个文件中只能有一个public类型的类。 例如:Rect和UseImport两个,分别在两个不同的包中。顺便回顾一下不同要用import导入。(哎,一直就没记住) //...
  • 语法格式:   定义的属性:修饰符 类型 属性名 = 初值 ;  定义的方法:修饰符 返回值类型 方法名 ( 参数列表... 属性:描述的静态特征,由对应类的成员变量组成. 方法描述的动态特征, 由对应类的成员方法...
  • 首先介绍一下AccessibleObject类的继承体系结构 AccessibleObject类的基本作用: 将反射对象标记为在使用时取消默认 Java 语言访问控制检查能力。 在反射对象中设置accessible 标志允许具有足够特权 public ...
  • 展开全部所谓对象就是客观事物在计算机中的抽象描述;...是把各种不同类型的数据(称为数据成员)和对数据的操作(成员函数)组织在一起而形成的用户自定义的数据类型。 C++中,定义包括说明和实现两大...
  • 静态类与非静态类的重要区别在于静态类不能实例化,也就是说,不能使用 new 关键字创建静态类类型的变量。在声明一个类时使用static关键字,具有两个方面的意义:首先,它防止程序员写代码来实例化该静态类;其次,...
  • Java 类的成员有哪些?

    千次阅读 2019-05-29 10:13:35
    类的成员有5:属性、方法、构造器、代码块、内部 具有相同属性(特征)和行为(动作)对象的集合,是抽象出来的。 属性:描述类型中的的特征(未完待续…) ...
  • 今天整理了一下以前学的JAVA的成员的修饰符,考试的时候...用于说明类的成员的访问权限。这种叫公有。在一个文件中只能有一个public类型的类。 例如:Rect和UseImport两个,分别在两个不同的包中。顺
  • 类型成员基础

    2011-09-17 22:16:34
    一个派生重写在它基类型中定义的成员时,C#编译器要求原始成员和重写成员具有相同的可访问性。也就是说,如果基类的成员是protected的,派生中的重写成员也必须是protected的。但这只是C#...
  • 静态类与非静态类的重要区别在于静态类不能实例化,也就是说,不能使用 new 关键字创建静态类类型的变量。在声明一个类时使用static关键字,具有两个方面的意义:首先,它防止程序员写代码来实例化该静态类;其次,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,947
精华内容 1,178
关键字:

具有类类型的成员