精华内容
下载资源
问答
  • 类的对象不能直接访问类声明的私有成员变量,否则破坏了信息隐藏的目的。 在C++中,为了防止某些数据成员或成员函数从外部被直接访问,可以将它们声明为private,这样编译器会阻止任何来自外部非友元的直接访问。 1...

    类的对象不能直接访问类声明的私有成员变量,否则破坏了信息隐藏的目的。
    在C++中,为了防止某些数据成员或成员函数从外部被直接访问,可以将它们声明为private,这样编译器会阻止任何来自外部非友元的直接访问。

    1.私有成员变量的四种访问方法

    (1)通过公共函数为私有成员赋值

    #include <iostream>  
    using namespace std;  
     
    class Test  
    {  
    private:  
    	int x, y;  
    public:  
    	void setX(int a)  
    	{  
    		x=a;  
    	}  
    	void setY(int b)  
    	{  
    		y=b;  
    	}  
    	void print(void)  
    	{  
    		cout<<"x="<<x<<'\t'<<"y="<<y<<endl;  
    	}  
    } ; 
     
    int main()  
    {  
    	Test p1;  
    	p1.setX(1);  
    	p1.setY(9);  
    	p1.print( );  
    	return 0;  
    }  

    (2)利用函数访问私有数据成员

    #include <iostream>  
    using namespace std;  
    class Test  
    {  
    private:  
    	int x,y;  
    public:  
    	void setX(int a)  
    	{  
    		x=a;  
    	}  
    	void setY(int b)  
    	{  
    		y=b;  
    	}  
    	int getX(void)  
    	{  
    		return x;   //返回x值  
    	}  
    	int getY(void)  
    	{  
    		return y;   //返回y值  
    	}  
    };  
    int main()  
    {  
    	Test p1;  
    	p1.setX(1);  
    	p1.setY(9);  
    	int a,b;  
    	a=p1.getX( );  
    	b=p1.getY();  
    	cout<<a<<'\t'<<b<<endl;  
    	return 0;  
    }     

    (3)利用引用访问私有数据成员

    #include <iostream>  
    using namespace std;  
    class Test  
    {  
    private:  
    	int x,y;  
    public:  
    	void setX(int a)  
    	{  
    		x=a;  
    	}  
    	void setY(int b)  
    	{  
    		y=b;  
    	}  
    	void getXY(int &px, int &py) //引用  
    	{  
    		px=x;    //提取x,y值  
    		py=y;  
    	}  
    };  
    int main()  
    {  
    	Test p1,p2;  
    	p1.setX(1);  
    	p1.setY(9);  
    	int a,b;  
    	p1.getXY(a, b); //将 a=x, b=y  
    	cout<<a<<'\t'<<b<<endl;  
    	return 0;  
    }  

    (4)利用指针访问私有数据成员

    #include <iostream>  
    using namespace std;  
    class Test  
    {  
    private:  
    	int x,y;  
    public:  
    	void setX(int a)  
    	{  
    		x=a;  
    	}  
    	void setY(int b)  
    	{  
    		y=b;  
    	}  
    	void getXY(int *px, int *py)  
    	{  
    		*px=x;    //提取x,y值  
    		*py=y;  
    	}  
    };  
    int main()  
    {  
    	Test p1;  
    	p1.setX(1);  
    	p1.setY(9);  
    	int a,b;  
    	p1.getXY(&a,&b);  //将 a=x, b=y  
    	cout<<a<<'\t'<<b<<endl;  
    	return 0;  
    }  

    详见 https://blog.csdn.net/KgdYsg/article/details/82492797?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522159922886019724839809393%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fall.%2522%257D&request_id=159922886019724839809393&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~first_rank_ecpm_v3~pc_rank_v3-2-82492797.pc_ecpm_v3_pc_rank_v3&utm_term=c%2B%2B%E8%AE%BF%E9%97%AE%E7%A7%81%E6%9C%89private%E6%88%90%E5%91%98%E5%8F%98%E9%87%8F%E7%9A%84%E5%B8%B8%E7%94%A8%E6%96%B9%E6%B3%95&spm=1018.2118.3001.4187

    2.在类外调用类的私有成员函数的两种方法

    (1).通过类的public成员函数调用private成员函数

     
    #include<iostream>
    using namespace std;
    class Test
    {
        public:
            void fun2()
            {
                fun1();
            }
        private:
            void fun1()
            {
                cout<<"fun1"<<endl;
            }
    };
    int main()
    {
        Test t;
        t.fun2();
        return 0;
    }

    (2).通过类的友元函数调用该类的private成员函数,但是该成员函数必须设为static,这样就可以在友元函数内通过类名调用,否则无法调用

     
    #include<iostream>
    using namespace std;
    class Test
    {
        friend void fun2(); //fun2()设为类Test的友元函数
     private:
         static void fun1()
         {
             cout<<"fun1"<<endl;
         }
    };
    void fun2()
    {
        Test::fun1();
    }
    int main()
    {
        fun2();
        return 0;
    }

    详见 https://blog.csdn.net/jackchoise030/article/details/86158780

    展开全文
  • C++ 类的私有成员

    千次阅读 2020-02-24 15:39:47
    C++ 类的私有成员 1. 类的私有成员 有了为类对象的数据成员赋值的构造函数,仍然允许程序的任何部分搞混实质上属于对象的成员,这大概有点儿矛盾。我们需要对类的数据成员采取保护措施。 在定义类成员时使用关键字 ...

    C++ 类的私有成员

    1. 类的私有成员

    有了为类对象的数据成员赋值的构造函数,仍然允许程序的任何部分搞混实质上属于对象的成员,这大概有点儿矛盾。我们需要对类的数据成员采取保护措施。

    在定义类成员时使用关键字 private,可以得到所需的安全性。通常情况下,私有类成员只能被类的成员函数访问。当然有一种情况例外。普通的函数没有访问私有类成员的直接途径。

    在这里插入图片描述

    指定私有类成员能够将类的接口与类的内部实现分开。类的接口由 public 成员和 public 函数成员组成,在必要时,public 函数成员可以提供对包括 private 成员在内的所有类成员的间接访问。例如,将类的内部成员指定为 private,就可以修改它们以改善性能,但不必修改通过公有接口使用这个类的代码。为了保证类的数据成员和函数成员的安全,使之免遭不必要的干预,将那些不需要暴露的成员声明为 private 是一种好习惯。仅将那些为了使用类而必需的成员声明为 public

    //============================================================================
    // Name        : std::class
    // Author      : Yongqiang Cheng
    // Version     : Version 1.0.0
    // Copyright   : Copyright (c) 2019 Yongqiang Cheng
    // Description : Hello World in C++, Ansi-style
    //============================================================================
    
    #include <iostream>
    
    using std::cout;
    using std::endl;
    
    class CBox                             // Class definition at global scope
    {
    public:
    	// Constructor definition using an initialization list
    	explicit CBox(double lv = 1.0, double wv = 1.0, double hv = 1.0) : m_Length { lv }, m_Width	{ wv }, m_Height { hv }
    	{
    		cout << "Constructor called." << endl;
    	}
    
    	// Function to calculate the volume of a box
    	double volume()
    	{
    		return m_Length * m_Width * m_Height;
    	}
    
    private:
    	double m_Length;                   // Length of a box in inches
    	double m_Width;                    // Width of a box in inches
    	double m_Height;                   // Height of a box in inches
    };
    
    int main()
    {
    	CBox match { 2.2, 1.1, 0.5 };        // Declare match box
    	CBox box2;                           // Declare box2 - no initial values
    
    	cout << "Volume of match = " << match.volume() << endl;
    
    	// Uncomment the following line to get an error
    	// box2.m_Length = 4.0;
    
    	cout << "Volume of box2 = " << box2.volume() << endl;
    
    	return 0;
    }
    
    
    Constructor called.
    Constructor called.
    Volume of match = 1.21
    Volume of box2 = 1
    
    

    2. 示例说明

    现在 CBox 构造函数声明为 explicit,从而可以避免我们不期望的隐式转换。CBox 类的定义现在包含两部分。前面是包含构造函数和成员函数 volume()public 部分,后面是包含数据成员的 private 部分。现在,3 个数据成员只能被本类的成员函数访问。不必修改任何成员函数,无论如何它们都可以访问本类的所有数据成员。然而,如果使 main() 函数中给对象 boxm_Length 成员赋值的语句不再是注释形式,那么将从编译器得到一条错误消息,说明该数据成员是不可访问的。如果还没有这样做,那么可以在 Class View 选项卡中看一下 CBox 类的成员。每个成员旁边的图标指出了该成员的可访问性。如果某成员是私有成员,则图标中将显示一个小挂锁。

    要记住的一点是,现在使用构造函数或成员函数是给对象的私有数据成员赋值的唯一方法。必须确保所有用于设定或修改类的私有数据成员的方法都是通过成员函数提供的。

    还可以将函数放入类的 private 部分。这种情况下,它们只能被同类的其他函数成员调用。如果将函数 volume() 放入 private 部分,则编译器将给出一条错误消息,因为 main() 函数中的语句试图使用这个函数。如果将构造函数放入 private 部分,那么将不能声明该类的任何对象。

    在数据成员定义成拥有 private 访问特性之后,CBox 类仍然可以正常工作。主要区别是这些成员现在被完全保护起来,不会遭受未经授权的访问和修改。

    如果没有另外指定,则类成员的默认访问特性都是 private。因此,我们可以将所有私有成员放在类定义的开始部分,并通过省略关键字 private,使它们拥有默认的private 访问特性。但任何情况下都显式指定访问特性则更好,这样对于我们的意图就不存在任何疑问了。

    当然,不必使所有数据成员都成为 private。根据类的用途,可以将某些数据成员定义为 private,而将另外一些定义成 public,这完全取决于我们的目的。如果没有将类成员指定为 public 的理由,则最好将它们指定为 private,这样可以使类更加安全。普通函数不能访问类的任何 private 成员。

    Standard Template Library,STL:标准模板库
    

    References

    Ivor Horton’s Beginning Visual C++ 2013
    http://www.wrox.com/WileyCDA/WroxTitle/productCd-1118845714.html

    展开全文
  • 类的私有成员变量和私有成员函数

    千次阅读 2013-03-30 20:22:26
    私有成员变量: 类的对象不能直接访问类声明的私有成员变量,否则破坏了信息隐藏的目的。  对象需要调用类的成员函数,达到访问类私有成员变量的目的。 私有成员函数: 一般属于internal的函数,被类中其他...

    私有成员变量:

    类的对象不能直接访问类声明的私有成员变量,否则破坏了信息隐藏的目的。 

    对象需要调用类的成员函数,达到访问类私有成员变量的目的。

    私有成员函数:

    一般属于internal的函数,被类中其他函数所调用,不对外提供接口。

    类对象是无法直接访问,也不应该直接访问。


    在C++中,为了防止某些数据成员或成员函数从外部被直接访问,可以将它们声明为private,这样编译器会阻止任何来自外部非友元的直接访问。
    展开全文
  • *公有成员 私有成员 保护成员 公有成员:关键字public将类成员声明为公有成员,可以被类对象及其所有成员访问。 私有成员:关键字private将类成员声明为私有成员,不能被类对象直接访问。 保护成员:关键字...

    *公有成员 私有成员 保护成员

    公有成员:关键字public将类成员声明为公有成员,可以被类对象及其所有成员访问。

    私有成员:关键字private将类成员声明为私有成员,不能被类对象直接访问。

    保护成员:关键字protected修饰的成员声明为保护成员,不能被类对象直接访问。其访问权限与私有成员近似,所不同的是其可对于基类的派生类是可见的,而私有成员则不可见。
    因此,为了便于派生类的访问,可以将基类的私有成员中需要提供给派生类访问的成员定义为保护成员。

       说白了就一句话,派生类可以访问protected权限的成员但是派生类的对象不能访问基类的成员
    

    注:但在类外引用成员函数时,派生对象只能引用基类的公有成员函数。

    展开全文
  • c++私有成员函数 私人会员功能 (Private Member Function) A function declared inside the class's private section is known as "private member function". A private member function is accessible through the...
  • C++ 私有成员

    千次阅读 2015-11-30 16:50:20
    类的成员默认为私有,私有成员不能被对象直接访问,只能通过在类中设定的接口函数来访问。在类中设置一个公有的借口函数,类的对象通过接口函数才能访问这个成员。  为什么要这么麻烦地设置私有数据成员,然后用...
  • 什么是私有成员? 从形式上看,如果成员名有两个下划线(__)开头则表示私有成员私有成员只允许类函数内部使用,类外部不能访问。 如果需要强制使用,使用方法是"对象名._类名__xxx" class One: def __init__...
  • 已经在类中定义的私有成员,为什么在成员函数中会被编译器认做未定义的标识符?
  • 私有成员访问

    2013-08-09 13:48:43
    类的成员函数可以访问类的私有成员的,友元函数是为了让除了类的成员函数以外的函数可以访问到类的私有成员
  • 面向对象——私有成员

    千次阅读 2016-02-24 14:23:34
    私有成员私有成员变量,私有成员函数; 对私有成员变量和私有成员函数的认识 私有函数的存在,避免冗余代码; 私有成员变量和私有成员函数一样只开放给自己,所谓只开放给自己, 对私有成员函数而言,私有成员...
  • 除了用类成员函数访问类私有成员变量外,还可以通过类对象地址来直接访问和修改类的私有成员变量
  • Java私有成员可以被子类继承

    千次阅读 2018-12-04 16:36:30
    之前在看书的是有一直有个错误认识,即私有成员不能被子类继承。 私有成员,可以被子类继承,只是在子类中不能直接访问,要在子类中访问父类的私有成员,需要通过父类的可见方法(非private修饰的方法)。 构造器...
  • 如何访问私有成员

    2019-05-24 22:33:00
    # ### 如何访问私有成员 class Plane(): # 公有属性 captain = "马军强" # 私有属性 __air_sister = "20个" # 公有绑定方法 def fly(self): print("飞机会飞") # 公有普通方法 def fly2():...
  • Python 类的私有成员

    千次阅读 2019-05-05 22:20:35
    大家都知道,一个类的私有成员只能在其所在的类里能够访问,而在外部是不行的。比如 C++ 或者 Java 的 private 关键字就是用来声明类的私有成员的,如果一个属性或者方法被 private 声明,那么这个成员就只能在类...
  • 私有成员变量的概念,在脑海中的现象是,以private关键字声明,是类的实现部分,不对外公开,不能在对象外部访问对象的私有成员变量. 然而,在实现拷贝构造函数和赋值符函数时,在函数里利用对象直接访问了私有...
  • C++ 基类私有成员会被继承吗

    万次阅读 多人点赞 2015-11-05 00:51:24
    1.派生类间接访问继承私有成员在类的继承中,类的私有成员在派生类中是“不可见“的,这种”不可见“是指在派生类的成员函数中,或者通过派生类的对象(指针,引用)不能直接访问它们。但是,不能直接访问并不代表不...
  • c++父类的私有成员能否继承

    千次阅读 2019-08-14 00:13:11
    1.子类可以间接访问父类私有成员 父类的私有成员函数和私有成员变量一样,只有该类内部的其他成员函数可以调用,对外是封蔽的。子类继承了父类的共有函数,且父类的公有函数调用了其内部的私有函数,此时子类调用...
  • pythonPython--私有成员 继承 类方法1.私有成员2. __del__方法3.继承(重要) Python–私有成员 继承 类方法 1.私有成员 概念: 私有成员 只能在 本类 内部使用 好处: 1.保护私有属性不被随意修改 2.提高封装性,将用户...
  • 本文主要介绍一下如何访问类的私有成员变量以及类的私有方法,这里以下面这个类来举例: @interface HomeController : UIViewController {  NSString *name2; } @property (nonatomic, copy) NSString *name...
  • 使用关键字private修饰的成员变量是私有成员变量 私有成员变量在本类中可以随意访问,但超出了类的范围就不能访问了。 要想访问私有成员变量,必须定义一对Getter/Setter方法 且方法必须以getXxx/setXxx规则命名 ...
  • java反射实现类外访问类的私有成员 学习本文需要提前掌握的知识:java类与对象 1、 思路分析 想要实现访问类的私有成员,我们有两个思路,一个是将私有成员转换成公有成员,另一个思路是在访问私有成员的时候绕过...
  • 私有成员 例题7.1 在圆柱体Cylinder中,创建类的私有成员,使之在该类的外部无法访问该成员。 package practice; class Cylinder{ private double radius; private int height; private double pi = 3.14; double ...
  • 关于类成员函数中访问同类对象的私有成员   原址:http://runfeel.iteye.com/blog/1904768 关于类成员函数中访问同类对象的私有成员,主要包含以下几种场景: a. 在C++的类的...
  • 我们接触C++的时候一定会涉及到保护成员和私有成员,并且我们知道这两个成员都不可以直接从外部进行访问,这两个成员的区别在哪呢? 我们涉及到概念叫做继承 1:如果B类以私有方式继承了A类,那么A类中的公有和保护...
  • 访问类私有成员变量

    千次阅读 2016-05-12 18:03:20
    下面列举了“非类成员”访问“类私有成员变量”的3种方法:  1.通过类公有成员函数set(), get()写、读私有成员;  2.通过类公有成员函数get()获取私有成员的指针或引用,对指针或引用操作;  3.通过友元。  ...
  • JavaScript中的公有成员,私有成员和静态成员 私有成员就是在类的内部实现中可以共享的成员。但是并不对外公开,JavaScript中并没有特殊的机制来定义私有成员,但是可以用一些技巧来实现这个功能。主要是通过变量的...
  • java中反射操作私有成员变量

    千次阅读 2017-06-09 11:58:00
    java中反射操作私有成员变量 反射private成员变量(字段) 反射private属性执行流程 1. 获取学生类字节码对象 2. 获取学生对象 3. 通过getDeclaredField方法获取私有字段 4. 通过...
  • C++中对私有成员变量进行赋值

    万次阅读 2018-04-26 18:09:16
    c++类成员的访问属性可以分为三种,分别是:公共成员(public),私有成员(private),受保护成员(protected)。在类对象的作用域内,公共成员在类的外部是可访问的。私有成员和受保护成员则不可以直接访问。下面...
  • C++类外直接访问私有成员

    千次阅读 2016-03-14 13:23:09
    C++类外面如何访问私有成员变量?只要有该对象的指针就可以访问。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 299,491
精华内容 119,796
关键字:

私有成员