精华内容
下载资源
问答
  • 很多人都知道C++是由结构体发展得来的,所以他们的成员变量(C语言的结构体只有成员变量)的内存分配机制... 类分为成员变量和成员函数,我们先来讨论成员变量。 一个类对象的地址就是所包含的这一片内存空间的

    (转载自:http://blog.sina.com.cn/s/blog_4feac7b90101keet.html)

    很多人都知道C++类是由结构体发展得来的,所以他们的成员变量(C语言的结构体只有成员变量)的内存分配机制是一样的。下面我们以类来说明问题,如果类的问题通了,结构体也也就没问题啦。 类分为成员变量和成员函数,我们先来讨论成员变量。 一个类对象的地址就是类所包含的这一片内存空间的首地址,这个首地址也就对应具体某一个成员变量的地址。(在定义类对象的同时这些成员变量也就被定义了)我们来以一段代码说明问题: //类的定义

    class K{
    public:
     K(){k = 12;}
     ~K(){}
     int k;
    }; 

    //类的使用//... K kTemp;
     printf("%d--%d\n",&kTemp,&kTemp.k);
     printf("%d--%d\n",sizeof(K),sizeof(kTemp.k));
     int *i = (int*)(&kTemp);
     int w = *i;
     printf("%d\n",w); 运行上面的代码,结果如下:1310588--1310588
    4--4
    12
    很明显,类的内存大小和其唯一的成员变量的内存大小是一致的。内存地址也是一致的。他们甚至可以相互转换。换成结构体结果也是一样。网友可以自己运行上面代码来进行确认。 这个时候,可能有人会提出疑问了。那么成员函数又如何?上面得代码就好像类没有任何成员函数一样,根本说明不了问题。 呵呵,所有的函数都是存放在代码区的,不管是全局函数,还是成员函数。要是成员函数占用类的对象空间,那么将是多么可怕的事情:定义一次类对象就有成员函数占用一段空间。 我们再来补充一下静态成员函数的存放问题吧:静态成员函数与一般成员函数的唯一区别就是没有this指针,因此不能访问非静态数据成员,就像我前面提到的,所有函数都存放在代码区,静态函数也不例外。所有有人一看到 static 这个单词就主观的认为是存放在全局数据区,那是不对的

    ----------第二篇------------

    c++是一种面向对象的编程语言,它向下保持了对c的兼容,同时也允许程序员能够自由的操控内存,虽然会带来一些问题,但这不是我们要探讨的问题,略过不表。类是对某种对象的定义,包含变量和方法,也可以理解为现实生活中一类具有共同特征的事务的抽象,他是面向对象语言的基础。所以类是不占有内存的,可是如果类生成实例那么将会在内存中分配一块内存来存储这个类。

        类的实例在内存中是如何分配内存的,有什么需要我们注意的,下面将慢慢到来。

        比如下面一个类:

        class A

        {};

        从形式上看,它似乎什么有没有,事实上它不止隐含了一个构造函数和一个析构函数,还有一些操作符重载函数,比如“=”。如果类A被实例话,如A a;在内存会占据多大的空间呢?有人可能会说4,也有人会说0,还有人会说1,说1的就对了,为什么会是1呢?原因有很多,如果我们定义一个数组A b[10];如果上面是0,这样的局面将会很尴尬,所以A这样一个空类,编译器会给它一个字节来填充。  

        增加一个变量,(字节对齐默认都是4)

        class  A

       {

         public:

           int i;

       }

      

       类A的实例将占据4个字节的内存,sizeof(A) = 4

       变量i 的初值被编译器指定位0xcdcdcdcd。

       再增加一个变量,

       class A

       {

          public:

          int  i;

          int  l;

       }

       此时按照变量生命的先后顺序,i被放在低地址上,l紧随其后。

       实例占用8个字节,sizeof(A) = 4*2 = 8

       如果类里面含有函数:

      class A

     {

         public:

          int i;

          int l;

          int add(int x,int y){return (x+y);}

     };

     有些人可能会说类的大小是12,事实上sizeof(A) = 8;

     为什么会这样,这是因为sizeof访问的程序的数据段,而函数地址则被保存在代码段内,所以最后的结果是8.

     再看下面这个情况

     class A

     {

          public:

             int i;

             int l;

             static int s;

             int add(int x,int y){return (x+y)};

     };

    此时sizeof(A)大小仍为8,这里留给读者去思考为什么?(^-^)。

    当类里面含有虚函数时,情况会如何呢?

     class A

     {

          public:

             int i;

             int l;

             static int s;

             virtual void Say(){};

             int add(int x,int y){return (x+y)};

     };

     因为含有虚函数,所以类里面将含有一个虚指针vptr,指向该类的虚表vtbl,一个指针占用四字节的地址,所以sizeof(A) = 12

     虚指针放在类实例地址的最低位置,

     比如 A *a = new A;

     我们可以这样给变量i赋值

     int *p = (int *)a;
     p++;
     *p = 1;//把i的值赋为1.

    如果类作为派生类,内存将如何分配呢?

    这种情况虽然有些复杂,但并不是说不好理解。

    他有多少个父类每个父类的大小加起来在加上自身就是sizeof的大小。

    转自:http://blog.csdn.net/alexwei2009/archive/2011/01/22/6157926.aspx

     

    //-----C++类对象内存结构[讲得很好] -------

    首先介绍一下C++中有继承关系的类对象内存的布局: 
    在C++中,如果类中有虚函数,那么它就会有一个虚函数表的指针__vfptr,在类对象最开始的内存数据中。之后是类中的成员变量的内存数据。 
    对于子类,最开始的内存数据记录着父类对象的拷贝(包括父类虚函数表指针和成员变量)。 之后是子类自己的成员变量数据。 
    对于子类的子类,也是同样的原理。但是无论继承了多少个子类,对象中始终只有一个虚函数表指针。 


    展开全文
  • Java —— 对象方法、成员方法、构造方法

    千次阅读 多人点赞 2019-02-13 18:22:08
    1.的定义 package 包名; class 类名 extend 父类 implements 接口名{ 成员属性;...2.对象 类名 对象名 = new 类名(); // 的创建 对象名.属性名 // 访问成员属性  3. 成员方法...

    修改自:https://www.cnblogs.com/shunran/p/3435670.html

    1.类的定义

    package 包名;
    class 类名 extend 父类 implements 接口名{
    	成员属性;
    	构造方法;
    	成员方法;
    }

    2.类的对象

    类名 对象名 = new 类名(); // 类的创建
    对象名.属性名 // 访问类的成员属性

      3. 类的成员方法

    /*定义·成员方法*/
    public 返回数据类型 方法名 (参数列表){
        语句;
    }

    4. 类的构造方法

      # 构造方法名和类名相同
    
      # 构造方法没有返回值
    
      # 主要作用 -- 完成对新对象的初始化
    
      #  在创建对象是,系统自动调用该类的构造方法
    
      #  一个类,可以有多个构造方法
    
      #  每个类都有一个默认的构造方法
    
    

    5. 类变量 、类方法

    /*类变量*/
    # 加上static修饰 -- 成为类变量或者静态变量, 否则为实例变量
    # 实例变量 -- 属于每个对象个体的属性
    # 类变量可以通过类名、类变量名、对象名 直接访问
    
    ---------------------------------------------------
    
    /*类方法*/
    # 类方法是与类相关的, 公共的方法
    # 类方法中不能访问非静态变量
    # 可以通过类名、类方法名、对象名 使用

     

     

    展开全文
  • 文章来源:... OC 面向对象 一般需要.h 和.m(或.mm 以后不赘述) 文件配合来创建。 .h 使用@inteface 和@end ,在之间定义,变量和方法只能定义,不能初始化 下为 Student.h @interface St

    文章来源:http://blog.csdn.net/jjwwmlp456/article/details/41826849

    OC 面向对象

    一般需要.h 和.m(或.mm 以后不赘述) 文件配合来创建类。


    .h 使用@inteface 和@end ,在之间定义,变量和方法只能定义,不能初始化

    下为 Student.h

    @interface Student : NSObject //@interface声明。  没有@interface  只有@implementation也能定义一个类

    {

    @public  //作用域  任意地方

    int a;

    @protected  //当前及子类 

    int b;

    @private  //当前(包括.m),

    int c;

    @package //框架中都可访问,,,没用过

    int d;

    }

    - (void) aa; //- 对象方法  调用[stu aa]

    + (void) ab; //+ 类方法    调用[Student aa] 

    - (void) ac:(int)pa; //带一个int 型参数 pa    [stu ac:pa]    

    - (int) ad:(int)pa  ae:(int)pb; //多个参数,可以有多个方法名   [stu ad:pa ae:pb]

    + (int) af:(int)pa:(int)pb; //多个参数,只保留第一个方法名   [stu af:pa :pb]

    @end

    注意:

    (1)在类的接口部分定义的员变量默认情况下是@protected的;

    (2)在类的实现部分定义的员变量默认情况下是@private的;

    (3)类的方法没有作用域之说,在接口部分定义的方法,相当于C++的public方法。在类的实现部分定义的方法,相对于C++的private方法。

    .m 使用@implementation 和 @end, 在之间定义。 变量和方法初始化的地方

    下为 Student.m

    #import "Student.h" 

    @implementation Student

    {

    int x; //在类的实现部分这里定义的变量,没有修饰符,默认为私有作用域,@private。一般也是用来定义隐藏信息的。

    }

    - (void) aa

    {

      //使用成员变量

      a = 8;

      self->c = 9; //self指代自身

    }

    + (void) ab

    {

      //静态方法中 不能调用成员变量

      //可以使用静态变量  

    }

    - (void) ac{}

    - (int) ad:(int)pa  ae:(int)pb{}

    + (int) af:(int)pa:(int)pb{}

    @end


    静态变量

    静态变量 使用的是c/c++的方式。 static 声明,只在文件oc中就是类中访问,生命周期为整个应用程序,即在下次访问时,会得到上次变化的值。

    OC没有类的静态成员变量,只有类的成员方法。

    static int x;

    @implementation Student

    //静态变量在 对象和类方法中都可使用

    - (void) test1

    {

      x = 3;

    }

    + (void) test2:(int)value

    {

      x = value;

    }

    @end


    main.m

    #import <Foundation/Foundation.h>

    int main()

    {

      //初始化对象 先分配内存,再初始化

      Student* stu = [Student alloc];  //调用方法以[]

      stu = [stu init]; 


      //初始化对象 分配并初始化

      Student* stu1 = [[Student alloc] init]; 


      //初始化对象 使用[Class new] 

      Student* stu2 = [Student new]; //OC2.0语法 ,new 先分配 后会调用默认的构造方法,即init方法

      

      //调用public变量   @protected、@private、static变量在这都不可使用

      stu->a = 3; 

      NSLog(@"a-value=%d", a);  

     

      //调用对象方法

      [stu ac:3];


      //调用静态方法

      [Student af:pa:pb];


      //Class 对象

      Class stuClz1 = [Student class];

      Class stuClz2 = [stu class];

      //Class 对象调用静态方法  

      [stuClz1 ab];  


      return 0;

    }


    变量作用域

    (一)变量的作用域主要分为四种:

    (1)@public (公开的)在有对象的前提下,任何地方都可以直接访问。

    (2)@protected (受保护的)只能在当前类和子类的对象方法中访问

    (3)@private (私有的)只能在当前类的对象方法中才能直接访问

    (4)@package (框架级别的)作用域介于私有和公开之间,只要处于同一个框架中就可以直接通过变量名访问

    (二)使用注意和补充

    1)在类的实现即.m文件中也可以声明成员变量,但是因为在其他文件中通常都只是包含头文件而不会包含实现文件,所以在这里声明的成员变量是@private的。在.m中定义的成员变量不能和它的头文件.h中的成员变量同名,在这期间使用@public等关键字也是徒劳的。

    2)在@interface  @end之间声明的成员变量如果不做特别的说明,那么其默认是protected的。

    3)一个类继承了另一个类,那么就拥有了父类的所有成员变量和方法,注意所有的成员变量它都拥有,只是有的它不能直接访问。


    展开全文
  • C++对象(下)——初始化列表、static成员和友元

    千次阅读 热门讨论 2021-03-08 09:23:18
    C++对象——初始化列表、static成员和友元一、再谈构造函数1.1 构造函数整体赋值1.2 初始化列表三级目录 关于C++对象的学习 C++对象(上)——的基本概念、的限定符及封装和类成员函数的this指针 C++...


    关于C++类和对象的学习
    C++类和对象(上)——类的基本概念、类的限定符及封装和类成员函数的this指针
    C++类和对象(中)——类的6个默认成员函数(构造、析构、拷贝构造、赋值运算符重载)
    在这里插入图片描述

    一、再谈构造函数

    1.1 构造函数整体赋值

    在创建对象时,编译器通过调用构造函数,给对象中各个成员变量一个合适的初始值。例如我们之前创建的Date类

    class Date
    {
    public:
    
    	Date(int year = 1900, int month = 1, int day = 1)
    	{
    		_year = year;
    		_month = month;
    		_day = day;
    	}
    
    private:
    	int _year;
    	int _month;
    	int _day;
    };
    

    虽然上述构造函数调用之后,对象中已经有了一个初始值,但是不能将其称作为类对象成员的初始化,构造函数体中的语句只能将其称作为赋初值,而不能称作初始化因为初始化只能初始化一次,而构造函数体内可以多次赋值

    1.2 初始化列表

    <1>为什么有初始化列表?

    对于我们定义的日期类,当类中出现以下成员时,如果只用构造函数则无法完成变量的初始化了,以下的成员变量需要在定义的时候就需要初始化

    • 引用成员变量
    • const成员变量
    • 自定义类型的成员变量

    在这里插入图片描述
    其次对于自定义的类成员变量,不使用初始化列表会调用多次构造函数
    在这里插入图片描述

    <2> 如何使用初始化列表

    初始化列表:以一个冒号开始,接着是一个以逗号分隔的数据成员列表,每个"成员变量"后面跟一个放在括号中的初始值或表达式
    注意:每个成员变量在初始化列表中只能出现一次

    //1.2.2
    class Time
    {
    public:
    	Time(int hour = 1, int minute=1,int second = 1)
    		:_hour(hour)
    		,_minute(minute)
    		,_second(second)
    	{
    		cout << "Time(int hour = 1, int minute=1,int second = 1)" << endl;
    	}
    private:
    	int _hour;
    	int _minute;
    	int _second;
    };
    
    class Date
    {
    public:
    	//初始化列表写法
    	Date(int year=1900, int month=1, int day=1,int hour=1,int minute=1,int second=1)
    		:_year(year)
    		,_month(month)
    		,_day(day)
    		,_n(10)
    		,_ref(day)
    		,_t(hour,minute,second)
    	{
    		cout << "Date(int year, int month, int day,int hour,int minute,int second)" << endl;
    
    	}
    
    private:
    	int _year;
    	int _month;
    	int _day;
    
    	//定义的时候需要初始化
    	int& _ref;	//引用
    	const int _n; //const成员变量
    	Time _t;	//自定义类型的成员变量
    };
    
    void Test2()
    {
    	Date d1(2021,3,9,2,2,2);
    }
    

    结果在这里插入图片描述

    <3> 成员变量在类中声明次序就是其在初始化列表中的初始化顺序,与其在初始化列表中的先后次序无关

    如下代码的运行结果是什么?

    //1.2.3
    class A
    {
    public:
    	A(int a)
    		:_a1(a)
    		, _a2(_a1)
    	{}
    	void Print() {
    		cout << _a1 << " " << _a2 << endl;
    	}
    private:
    	int _a2;
    	int _a1;
    };
    
    void Test2()
    {
    	A aa(1);
    	aa.Print();
    }
    

    结果

    在这里插入图片描述

    1.3 explicit关键字

    <1> 匿名对象

    匿名对象顾名思义就是没有名字,其作用域只在一行中有效,例如下面的代码

    //1.3.1
    class B
    {
    public:
    	B(int b = 0)
    		:_b(b)
    	{
    		cout << "B(int b = 0)" << endl;
    	}
    
    	//析构函数
    	~B()
    	{
    		cout << "~B()" << endl;
    	}
    private:
    	int _b;
    };
    
    int main()
    {
    	B bb(10);	//生命周期在main函数域
    	B(2);	//匿名对象生命周期在这一行
    	return 0;
    }
    

    在这里插入图片描述
    在这里插入图片描述

    <2> 为什么有explicit关键字?

    对于c++来说,构造函数不仅可以构造与初始化对象,对于单个参数的构造函数,还具有类型转换的作用

    当我们定义一个类进行初始化时,如果我们采取下面这种定义方式,编译器会自动生成一个匿名对象,然后用匿名对象对cc对象进行拷贝构造

    //1.3.2
    class C 
    {
    public:
    	C(int c)
    		:_c(c)
    	{
    		cout << "C()" << endl;
    	}
    
    private:
    	int _c;
    };
    
    int main()
    {
    	C cc(2);
    	cc = 8;	//编译器会自动生成一个匿名对象,然后用匿名对象对cc对象进行拷贝构造
    	return 0;
    }
    

    <3> 如何使用explicit关键字?

    用explicit修饰构造函数,将会禁止单参构造函数的隐式转换

    //1.3.3
    class C 
    {
    public:
    	explicit C(int c)
    		:_c(c)
    	{
    		cout << "explicit C(int c)" << endl;
    	}
    
    private:
    	int _c;
    };
    
    int main()
    {
    	C cc(2);
    	cc = 8;	//编译器会自动生成一个匿名对象,然后用匿名对象对cc对象进行拷贝构造
    	return 0;
    }
    

    在这里插入图片描述

    二、static成员

    2.1 概念

    声明为static的类成员称为类的静态成员,用static修饰的成员变量,称之为静态成员变量;用static修饰的成员函数,称之为静态成员函数。静态的成员变量一定要在类外进行初始化

    面试题:实现一个类,计算程序中创建出了多少个类对象?这个时候我们就可以使用static成员变量和static成员函数来实现

    //2.1 实现一个类,计算程序中创建出了多少个类对象。
    class A
    {
    public:
    	//构造函数
    	A()
    	{
    		++_scount;
    	}
    	//拷贝构造函数
    	A(const A& a)
    	{
    		++_scount;
    	}
    	
    	static int GetAcount()
    	{
    		return _scount;
    	}
    private:
    	static int _scount;
    };
    
    //初始化在类外
    int A::_scount = 0;
    
    void TestA()
    {
    	cout << A::GetAcount() << endl;
    	A aa;
    	A bb;
    	A cc(bb);
    	cout << A::GetAcount() << endl;
    }
    

    在这里插入图片描述

    2.2 特性

    <1> 静态成员为所有类对象所共享,不属于某个具体的实例

    <2> 静态成员变量必须在类外定义,定义时不添加static关键字

    在这里插入图片描述

    <3> 类静态成员即可用类名::静态成员或者对象.静态成员来访问

    在这里插入图片描述

    <4> 静态成员函数没有隐藏的this指针,不能访问任何非静态成员

    在这里插入图片描述

    <5>静态成员和类的普通成员一样,也有public、protected、private3种访问级别,也可以具有返回值

    Q1: 静态成员函数可以调用非静态成员函数吗?

    不可以,因为静态成员函数没有隐藏的this指针

    Q2:非静态成员函数可以调用类的静态成员函数吗?

    可以,因为非静态成员函数含有this指针,指定了静态成员函数的类域
    在这里插入图片描述

    三、C++11的成员初始化新玩法

    3.1 为什么?

    对于C++98而言,类内自定义的内置类型,编译器会进行初始化,而其他内置类型不会,因此出现则会中初始化方法。
    具体查看这篇博客的2.2.7节内容
    C++类和对象(中)——类的6个默认成员函数(构造、析构、拷贝构造、赋值运算符重载)
    在这里插入图片描述

    3.2 怎么用?

    C++11支持非静态成员变量在声明时进行初始化赋值,但是要注意这里不是初始化,这里是给声明的成员变量缺省值

    //3.C++11的成员初始化新玩法
    class B
    {
    public:
    	B(int b = 0)
    		:_b(b)
    	{}
    	int _b;
    };
    class A
    {
    public:
    	void Print()
    	{
    		cout << a << endl;
    		cout << b._b << endl;
    		cout << p << endl;
    	}
    private:
    	// 非静态成员变量,可以在成员声明时给缺省值。
    	int a = 10;
    	B b = 20;
    	int* p = (int*)malloc(4);
    	//静态成员不可以
    	static int n;
    };
    int A::n = 10;
    
    int main()
    {
    	A a;
    	a.Print();
    	return 0;
    }
    

    在这里插入图片描述

    四、友元

    • 友元分为:友元函数友元类
    • 友元提供了一种突破封装的方式,有时提供了便利。但是友元会增加耦合度,破坏了封装,所以友元不宜多用

    4.1 友元函数

    问题:现在我们尝试去重载operator<<,然后发现我们没办法将operator<<重载成成员函数。因为cout的输出流对象和隐含的this指针在抢占第一个参数的位置。this指针默认是第一个参数也就是左操作数了。但是实际使用中cout需要是第一个形参对象,才能正常使用。所以我们要将operator<<重载成全局函数。但是这样的话,又会导致类外没办法访问成员,那么这里就需要友元来解决。operator>>同理

    //4.1
    class Date
    {
    public:
    	Date(int year, int month, int day)
    		: _year(year)
    		, _month(month)
    		, _day(day)
    	{}
    	ostream& operator<<(ostream& _cout)
    	{
    		_cout << _year << "-" << _month << "-" << _day;
    		return _cout;
    	}
    private:
    	int _year;
    	int _month;
    	int _day;
    };
    int main()
    {
    	Date d(2017, 12, 24);
    	d << cout;
    	return 0;
    }
    

    在这里插入图片描述
    友元函数可以直接访问类的私有成员,它是定义在类外部的普通函数,不属于任何类,但需要在类的内部声明,声明时需要加friend关键字

    //4.1
    class Date
    {
    friend ostream& operator<<(ostream& _cout, const Date& d);
    friend istream& operator >> (istream& _cin, Date& d);
    
    public:
    	Date(int year, int month, int day)
    		: _year(year)
    		, _month(month)
    		, _day(day)
    	{}
    	ostream& operator<<(ostream& _cout)
    	{
    		_cout << _year << "-" << _month << "-" << _day;
    		return _cout;
    	}
    private:
    	int _year;
    	int _month;
    	int _day;
    };
    
    ostream& operator<<(ostream& _cout, const Date& d)
    {
    	_cout << d._year << "-" << d._month << "-" << d._day << endl;
    	return _cout;
    }
    
    istream& operator >> (istream& _cin, Date& d)
    {
    	_cin >> d._year >> d._month >> d._day;
    
    	return _cin;
    }
    
    int main()
    {
    	Date d(2017, 12, 24);
    	cout<<d;
    	//Date d1;
    	cin >> d;
    	cout << d;
    	return 0;
    }
    

    在这里插入图片描述

    4.2 友元类

    友元类的所有成员函数都可以是另一个类的友元函数,都可以访问另一个类中的非公有成员。

    • 友元关系是单向的,不具有交换性。
      比如下面Time类和Date类,在Time类中声明Date类为其友元类,那么可以在Date类中直接访问Time类的私有成员变量,但想在Time类中访问Date类中私有的成员变量则不行。
    • 友元关系不能传递
      如果B是A的友元,C是B的友元,则不能说明C时A的友元。
    class Date; // 前置声明
    class Time
    {
    	friend class Date; // 声明日期类为时间类的友元类,则在日期类中就直接访问Time类中的私有成员变量
    public:
    	Time(int hour=0, int minute=0, int second=0)
    		: _hour(hour)
    		, _minute(minute)
    		, _second(second)
    	{}
    private:
    	int _hour;
    	int _minute;
    	int _second;
    };
    
    class Date
    {
    public:
    	Date(int year = 1900, int month = 1, int day = 1)
    		: _year(year)
    		, _month(month)
    		, _day(day)
    	{}
    
    	void SetTimeOfDate(int hour, int minute, int second)
    	{
    		// 直接访问时间类私有的成员变量
    		_t._hour = hour;
    		_t._minute = minute;
    		_t._second = second;
    	}
    private:
    	int _year;
    	int _month;
    	int _day;
    
    	Time _t;
    };
    

    五、内部类

    概念:如果一个类定义在另一个类的内部,这个内部类就叫做内部类。注意此时这个内部类是一个独立的类,它不属于外部类,更不能通过外部类的对象去调用内部类。外部类对内部类没有任何优越的访问权限。

    注意:内部类就是外部类的友元类。注意友元类的定义,内部类可以通过外部类的对象参数来访问外部类中的所有成员。但是外部类不是内部类的友元。

    特性:

    1. 内部类可以定义在外部类的public、protected、private都是可以的。
    2. 注意内部类可以直接访问外部类中的static、枚举成员,不需要外部类的对象/类名。
    3. sizeof(外部类)=外部类,和内部类没有任何关系
    class A
    {
    private:
    	static int k;
    	int h;
    public:
    	class B
    	{
    	public:
    		void foo(const A& a)
    		{
    			cout << k << endl;//OK
    			cout << a.h << endl;//OK
    		}
    	};
    };
    int A::k = 1;
    int main()
    {
    	A::B b;
    	b.foo(A());
    	return 0;
    }
    
    展开全文
  • C++程序的内存格局通常分为四个区:全局...所有类成员函数和非成员函数代码存放在代码区;为运行函数而分配的局部变量,函数参数,返回数据,返回地址等存放在栈区;余下的空间都被称为堆区. 根据这个解释,我们可以得知在
  • java成员对象

    千次阅读 2016-11-28 16:16:05
    最简单地复用某个的方式就是直接使用该的一个对象,此外也可以将那个的一个对象置于某个新中。我们称其为“创建一个成员对象”。新的类可以由任意数量、任意类型的其他对象以任意可以实现新的中想要的功能...
  • 看了一下,现在的CSDN大多都是Python2来编写例子,今天边学习,边进行修改为Python3,大家互相学习 面向对象是一种编程方式,此编程方式的实现是基于对 对象 的...成员可以分为三大:字段、方法和属性...
  • 中默认的六个成员函数 构造函数 析构函数 拷贝构造函数 赋值操作符重载 取地址和const取地址操作符重载 const成员函数 1. 中默认的六个成员函数 首先看看下面代码 class A{ }; int main(){ A a; return 0; } ...
  • 对象与接口概念

    千次阅读 2019-02-21 23:14:27
    ​ 一个定义在另外一个的内部,分为成员内部(定义在外部的成员位置)和局部内部(定义在外部的方法里面) 成员内部 class Outer{ class Inner{} } 成员内部的特点 1、成员内部类可以直接访问外部的...
  • Java 内部成员类、局部、匿名

    万次阅读 多人点赞 2016-10-11 17:49:15
    Java各种称呼详解Java有各种各样,内部、嵌套成员类、局部(本地)、静态、匿名、文件以及这些组合起来的称呼成员内部成员匿名成员嵌套,本地匿名等,真是多的不行,但有些其实...
  • 我们首先看一段程序: class A { private : ...这个程序非常的简单,但我们仔细一瞅会发现一个有趣的问题:private的变量i怎么直接可以通过对象访问了!...其他对象的数据成员可以通过引用或指针间接指明)
  • 实例成员类成员

    千次阅读 2018-05-26 10:48:09
    体中包括成员变量的声明与方法的定义,而成员变量又可以分为实例变量和变量。在声明成员变量的时候,用关键字Static修饰的为变量,否则称作实例变量。实例变量与变量的区别:*不同对象的实例变量互不相同*...
  • 对象数组实例(栈中实例化和堆中实例化):class Coordinate { public: int m_iX; int m_iY; };int main() { Coordinate coord[3];//栈中实例化 coord[1].m_iX = 10; Coordinate *p = new Coordinate[3];//堆中...
  • Java类成员

    千次阅读 2016-06-04 16:14:30
     Java类成员分为实例成员和静态成员。 1.1 实例成员  Java中的实例成员是属于对象的,它包括实例变量和实例方法,只能创建对象后,通过对象引用访问实例变量和实例方法。  实例变量,在进行实例化时,才...
  • 中包含成员变量和成员函数,成员变量又分为静态成员变量和非静态成员变量,成员函数又分为静态成员函数和非静态成员函数; 他们之间的访问关系如下: 非静态成员函数可以访问非静态成员变量,也可以访问静态成员...
  • 0. 的编译中,先编译成员变量和成员函数的额声明,成员函数的定义在声明结束后再处理; 1. 中,多个代码区块public或者private最终会被按区块统一,然后编译过程中,后定义的成员变量地址高于定义的成员变量...
  • 普通成员变量受到public和private两个关键字的限制,可以通过对象名访问具有public的普通成员变量,普通的成员变量不能够在对象之间共享。 静态成员变量 1.在C++中可以定义静态成员变量和静态成员函数...
  • C++类成员指针

    千次阅读 2015-10-28 16:54:53
    成员指针分为成员函数指针和成员数据指针。2. 成员函数指针在事件驱动和多线程应用中被广泛用于调用回调函数。在多线程应用中,每个线程都通过指向成员函数的指针来调用该函数。在这样的应用中,如果不用成员指针,...
  • Java访问权限的修饰符public,private,protected,缺省(default)一个中的成员变量和成员方法(非静态)被访问分为两种场景,一是在该中,或其子类中访问,二是创建该对象进行访问。假设:有三个 class ...
  • JAVA 面向对象 成员变量和局部变量

    万次阅读 多人点赞 2016-07-20 18:08:42
    在 Java语言中, 根据定义变量位置的不同,可以将变量分成两大:成员变量 局部变量 成员变量和局部变量的运行机制存在很大差异,下面我们看看差异在哪. 成员变量 成员变量指的是在里定义的变量. 局部变量指的是...
  • 对象方法和方法

    千次阅读 2018-06-10 09:50:45
    方法名调用方法不可以调用实例方法,但是可以创建对象来访问实例方法方法不可以使用实例变量,但可以使用self对象方法(-)表示对象方法对象方法只能由实例变量来调用对象方法可以访问当前对象成员变量对象...
  • 对象(Java)

    千次阅读 2019-12-29 08:58:03
    对象对象的一个实例,有状态和行为,软件对象的状态就是属性,行为通过方法体现。在软件开发中,方法操作对象内部状态的改变,对象的相互调用也是通过方法来完成。...成员变量:成员变量是定义在中,方法...
  • Java对象与Java

    千次阅读 多人点赞 2021-07-28 22:23:35
    什么是2.Java类类的结构Java的格式3.java对象4.对象5.中的变量,方法1.变量分类2.方法分类6.方法重载7.对象与引用基本类型和引用类型的区别:值传递与引用传递8.static关键字概念static属性static方法代码...
  •  A内部提供了更好的封装,可以把内部隐藏在外部之内,不允许同一个包中的其他访问该。  B内部的方法可以直接访问外部的所有数据,包括私有的数据。  C内部所实现的功能使用外
  • 静态成员的所有对象共享的成员,而不是某个对象成员。 静态成员分为静态数据成员和静态成员函数 2.静态数据成员 如果某个属性为整个所共有,不属于任何一个具体对象,则采用static关键字来声明为静态数据...
  • 成员变量初始化总结

    万次阅读 2015-04-08 11:52:23
    首先把需要初始化的成员变量分为: Ø 一般变量(int) Ø 静态成员变量(static int) Ø 常量(const int ) Ø 静态常量(static const int)  对应的初始化方式是: Ÿ 一般变量可以在初始化列表里或者...
  • 对象——登堂入室

    千次阅读 热门讨论 2021-03-05 07:58:56
    如上图所示,尽管构造函数被调用后,对象中已经有了一个初始值,但是这不能称为类对象成员的初始化。因为调用构造函数的时候就已经进行了对象成员的定义,构造函数体内的语句只能将其称之为赋初值。且初始化只能初始...
  • C#的数据成员

    千次阅读 2015-09-08 16:11:23
    在看过对象之后,来了解一下成员成员分为两个大,一是数据成员,另一是函数成员: 数据成员:字段、常量、事件。 函数成员:方法、属性、索引器、构造函数、析构函数、操作符。  字段:字段...
  • 3. 对象的初始化和清理3.1 构造函数和析构函数3.2 构造函数的分类及调用3.3 拷贝构造函数调用时机3.4 构造函数调用规则3.5 深拷贝与浅拷贝3.6 初始化列表3.7 类对象作为类成员4.2.8 静态成员 3. 对象的初始化和清理 ...
  • [C/C++]详解C++的对象

    万次阅读 多人点赞 2021-05-24 13:09:01
    对象是具有类型的变量。对象是面向对象编程技术中的最基本的概念。 1.面向对象 首先来理解什么是面向对象编程。 C语言是面向过程的,关注的是过程,分析出求解问题的步骤,通过函数调用逐步解决问题。 C++是...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 220,157
精华内容 88,062
关键字:

对象可以分为类的哪些成员