【转】属性与字段的区别

【转】属性与字段的区别

首先从两者的声明上来看，公共字段只是类用public修饰符所公开的简单公共变量，而属性则是对字段的封装，它使用get和set访问器来控制如何设置或返回字段值。

由于属性的实质是方法（get或set方法），在IL中是没有属性的概念的。所以对于开发过程中常用的赋值和取值操作来说，使用公共变量肯定会比使用属性速度要快，性能上也稍高（方法和变量哪个速度不用说了吧）。

公共字段虽然在速度上快，但它必须开放字段为public，这样一来对象的调用者便可以直接修改其值，值的内容是否合法，运行中是否会出错，就没有了保障，进而会大大降低类的可重用性；相反，属性类似于方法，它可以对存入的变量的值进行处理，如果觉得该值不合法，可以就地变换或者直接提出警告。这对该类的对象的使用安全有很大好处，在运行过程中，因公共变量值的错误而产生的问题会大大减少。

从上述内容来看，两者各有优缺点，在实际项目开发过程中，我们究竟选择使用哪一种方式呢？

如果满足下面几个条件，那么我们便可以大胆地使用公共字段：

1． 允许自由读写；

2． 取值范围只受数据类型约束而无其他任何特定限制；

3． 值的变动不需要引发类中其它任何成员的相应变化；

属性的使用条件则恰好跟变量相反，只要满足下面任何一个条件，就应该使用属性：

1． 要求字段只能读或者只能写；

2． 需要限制字段的取值范围；

3． 在改变一个字段的值的时候希望改变对象的其它一些状态；

总结：虽然在实际项目的开发过程中，公共字段和属性在合适的条件下都可以使用，但是我们应该尽可能的使用属性（property），而不是数据成员（field）；把所有的字段都设置为私有字段，如果要暴露它们，则把它们封装成属性，这也是微软推荐的方式。

尽可能的使用属性（property），而不是数据成员（field）。
把所有的字段都设为私有字段，则把它们封装成属性,字段就是作用于整个类的变量。   
属性的实质是方法（get和set方法），数据安全  

小结：引入属性的优点

1.维护私有字段（保证类的封装性）

2.可控制访问(只读/只写，确保赋值的正确性等)

3.不用注重细节（直接使用，不需要考虑复杂的处理代码）

至于引入属性的益处在更多的c#程序中会领会的愈加深入

问题：什么情况下选择使用字段还是属性？

从例子中可看到属性其实就是对私有字段的读取和写入，以便做些公有字段无法完成的任务，他的使用方式和公有字段完全一样，所以可以理解成属性是为了满足对公有字段的特殊需求而产生的附属品。因而当我们选择使用属性还是使用字段时，主要看需求，如果不需设置访问权限、不需在赋值时检测值是否满足要求、不需要在赋值时修改对象其他一些状态等特殊的需求时，使用公有字段即可，否则就使用属性。

 

objc--对于Retain和Assign属性的理解

在写程序时，对于要定义的变量进了习惯于加上retain属性，但对其到底起到什么作用却一直不是很明白，今天做了一个demo，终于弄清了他们的意思。

比如我要定义一下字符串var：

NSString *var;

声明Property时，@property（nonamtic，assign）NSString *var;

将属性声明为Assign,当使用@Synthsize生成Getter和Setter方法后，我们就可以用“.”操作符来为var赋值，

将属性声明为Assign时，Setter方法的实现是这样的：

-（void）setter:(NSString*)str

{

　　　var=str;

}

var=[[NSString alloc]initWithString:@"aaa"];

当我们这样用时，没有调用Setter方法，只是将var指向目标地址，这时

NSLog（@“%d”，[var retainCount]）;的值会是1。

如果我们这样写：self.var=[[NSString alloc]initWithString:@"aaa"];

这时会调用setter方法，但是NSLog（@“%d”，[var retainCount]）;的值仍然是1。

如果我们在设置属性时这样来设置：

@property（nonamtic，retain）NSString *var;

这时，自动生成的Setter方法是这样的：

-（void）Setter：（NSString*）str

｛

　　[str retain];

　　[var release];

　　var=str;

｝

这样就一目了然了，也就是被设置为retain属性的方法，在生成Setter方法时，先将要赋的值的引用计数加1，然后将var指向的对象release。再后才是将str赋值给var。这时下面的代码的输出结果会是2，因为，在Setteryyif中[[NSString alloc]initWithString:@"aaa"]所指的内存区域的retain被加了1，然后var又指向这个区域，所以var的retainCount自然就为2了：

self.var=[[NSString alloc]initWithString:@"aaa"];

NSLog（@“%d”，[var retainCount]）;

这样做是为了防止内存被过渡释放，比如，[[NSString alloc]initWithString:@"aaa"]这个内存区域不光有var指向，还有另外一个变量var2也指向这个区域，如果我们不设置成retain属性，在执行var=[[NSString alloc]initWithString:@"aaa"];后，var和var1都指向一个共同的内存区域，但这个内存区域的retainCount为1。如果在另一个地方执行了[var2 release];这样[[NSString alloc]initWithString:@"aaa"]所指的内存区域的retainCount为0，所以这个内存区域就被释放了，var也就成了野指针，这时再引用var将会出现内存错误。

但是，需要特别注意的是，即使我们设置var的属性为retain，如果我们在为var赋值时，使用的是如下形式：

var=[[NSString alloc]initWithString:@"aaa"];

而不是：

self.var=[[NSString alloc]initWithString:@"aaa"];

这样retain属性是不起作用的，前面不加self.，相当于我们定义的属性还是assign。retainCount不会加1的。

我个人对这个的理解是，如果不显示的使用"."操作符，Setter方法是不调用的，仅仅是指针的传递。

今天又有了点新的想法，补充一下：

"."操作符在OBJC中是方法的调用，比如：self.str和[self str]是一样的。如果我在.h文件中声明了一个方法：

-(void)method;

那么，我调用这个方法可以用两种方式：[self method]或self.method。

这样说的话，我们为什么可以用诸如self.str这样的形式来表示一个变量呢，原因就在于OBJC中变量属性的机制。

我们前面说过，定义一个变量str，加个assign或retain之类的属性后，再用@synthesize就可以生成相应的setter和getter方法了。这样，对于一个变量，就有了相应的赋值方法，于是，对于self.str这样的写法，实际上就是调用了str对应的setter或getter方法。换句话说，也是把setter或getter消息发送给和str。str这时就是一个方法名，而不仅仅是变量名了。

所以如果我们没有对一个变量声明属性，也没有@synthesize来生成setter和getter方法，那么我们就不能用self.str这种形式，而只能用str=@"aaa",或者str1=str这样的形式来使用变量。

于是也就有了我们前面的结论：用self.str这种形式，相当于调用setter或getter方法。也就会执行retain的操作。不用这种形式，就没用调用setter或getter方法，retain的操作也就无从谈起。

转一个另一篇文章，讲的比较好：

最近有人问我关于什么时候用self.赋值的问题, 我总结了一下, 发出来给大家参考. 有什么问题请大家斧正.

    关于什么时间用self. , 其实是和Obj-c的存取方法有关, 不过网上很多人也都这么解答的, 那它为什么和存取方法有关? 怎么有关的? 并没有多少人回答出来. 同时关于内存管理的内容, 请大家看旺财勇士的Objective-C内存管理总结～CC专版 , 有些东西我就不多解释了.

    进入正题, 我们经常会在官方文档里看到这样的代码:

MyClass.h

@interface MyClass : NSObject {
    MyObject *myObject;
}
@property (nonatomic, retain) MyObject *myObject;
@end

MyClass.m

 
@synthesize myObject;
 
-(id)init{
    if(self = [super init]){
        MyObject * aMyObject = [[MyObject alloc] init];
        self.myObject = aMyObject;
        [aMyObject release];
    }
    return self;
}

有人就问, 为什么要这么复杂的赋值? 为什么要加self. ? 直接写成self.myObject = [[MyObject alloc] init];不是也没有错么? 不加self有时好像也是正常的?

现在我们来看看内存管理的内容:

先看间接赋值的:

1.加self.

 MyObject * aMyObject = [[MyObject alloc] init]; //aMyObject retainCount = 1;
 self.myObject = aMyObject; //myObject retainCount = 2;
 [aMyObject release];//myObject retainCount = 1;

2. 不加self.

MyObject * aMyObject = [[MyObject alloc] init]; //aMyObject retainCount = 1;
myObject = aMyObject; //myObject retainCount = 1;
[aMyObject release];//对象己经被释放

再看直接赋值的:

3.加self.

self.myObject = [[MyObject alloc] init]; //myObject retainCount = 2;

4. 不加self.

myObject = [[MyObject alloc] init]; //myObject retainCount = 1;

现在是不是有点晕, 我们先来把代码改一下, 官方的一种常见写法:

MyClass.h

@interface MyClass : NSObject {
    MyObject * _myObject;
}
@property (nonatomic, retain) MyObject *myObject;
@end

MyClass.m

@synthesize myObject = _myObject;

OK, 你现在再试下, 如果你用self._myObject = aMyObject; 或者 myObject = aMyObject; 你会得到一个错误, 为什么呢, 这里就是和Obj-c的存取方法有关了. 说白了很简单 , 大家都知道, @property (nonatomic, retain) MyObject *myObject; 是为一个属性设置存取方法, 只是平时我们用的方法名和属性名是一样的,现在你把它写成不同的名字, 就会很清楚了. _myObject是属性本身, myObject是存取方法名.

现在我们知道self.是访问属性的存取方法了, 那存取方法又怎么工作的? self.myObject = [[MyObject alloc] init]; 为什么会有内存泄露?
关于nonatomic我不多解释了, 它不是我要讲的重点, 而且我也没完全搞清楚, 不误导大家. 我只说assign, retain ,copy.

get方法是:

-(MyObject*)myObject{
    return _myObject;
}

Set方法是:

// assign 
-(void)setMyObject:(id)newValue{
    _myObject = newValue; 
}
// retain 
-(void)setMyObject:(id)newValue{
    if (_myObject != newValue) { 
        [_myObject release]; 
        _myObject = [newValue retain]; 
    }  
}
// copy 
-(void)setMyObject:(id)newValue{
    if (_myObject != newValue) { 
        [_myObject release]; 
        _myObject = [newValue copy]; 
    } 
}

其实这些方法里还有别的内容, 并不只是这些. 而且这些方法可以被重写. 比如你写一个

-(MyObject*)myObject{
    return _myObject;
}

放在你的类里, 你调用self.myObject时(不要把它放在等号左边, 那会调用get方法)就会调用这个方法.

这里多说一句, @property 是为你设置存取方法, 和你的属性无关, 你可以只写一句

@property (readonly) NSString *name;

在你的类里实现

-(NSString*)name{
    NSLog(@"name");
    return @"MyClass";
}

同样可以用self.name调用.

现在回头说说我们开始的那四个赋值, 当不用self.的时候,  那句话只是一般的赋值, 把一个指针赋给另一个指针, 不会对分配的内存有任何影响, 所以2中不要最后[aMyObject release];这句话和4是一回事. 这里就不多说了.我们看看1和3,
当调用setMyObject:方法时, 对newValue 做了一次retain操作, 我们必须把原来的newValue释放掉, 不然就会内存泄露, 在1里, 我们有个aMyObject可以用来释放, 在3里, 我们无法释放它, 所以, 在3里, 我们会多出来一个retainCount. 内存泄露了.

说了这么多, 我只想让大家清楚, 什么是调用属性本身, 什么是调用存取方法. 怎么样才能避免内存泄露, 而且, 以上例子里是在自己类里的调用, 如果这个类被别的类调用时, 更要注意一些,

顺便说一下, 如果你想在其它类访问对象属性, 而不是通过存取方法, 你可以用myClass -> myObject来访问, 这样是直接访问对象本身, 不过你先要把myObject设成@public. 但这个是官方不提倡的,

代码比较简单, 我还是发出来, 高人们可以忽略了.

原文地址：http://www.cnblogs.com/wwwkhd/archive/2011/04/21/2023766.html

C++类成员属性的一种简洁实现

    C++类成员属性的一种简洁实现

    一般来说对于标准C++而言是不存在成员属性这个概念的，以前大家都是用GetXXX/SetXXX来访问或取得数据，好象也没有感觉到任何不便。但是当我们用过C#之类的语言之后，我们总觉得C++这个方式太老土了。于是我们想去实现“属性”这个C++语言缺乏的要素。事实上网络上有很多人已经做了这部分工作，实现的方法有很多种，一种是用模板，一种是根据特定语言来写的，如VC（指的是Microsoft实现的C++）。但是它们要么很复杂，要么很难记住它的准确用法，嗯我总是喜欢简单的东西，因为太复杂的东东会让我的头脑当机。废话少说，来看看如何实现。
在实现之前，我必需先探讨一下为什么需要“属性”这个东东。比如说下面雇员这个类：

1. 1. class CEmployee
   2. {
   3. public:
   4.   int Old; //年龄
   5. };
   6. CEmployee employee;
   7. employee.Old=22;
   8. int old =employee.Old;

    它有一个成员变量，我们可以直接对它们进行赋值或者读取，但是往往会缺少一个很重要的东东，就是不能对所赋值进行校验，这可是个大问题，比如我们给Old一个负值，比如-50，程序运行时不会有任何错误，但是的确这个成员变量的值在逻辑上是不正确的。于是我们会写上GetOld、SetOld。现在OK了，这个小问题解决了，但新问题来了。我们的类使用者，他们需要重新把他们的代码成写如下的样子，而不是上面的那样。

1. 1.   CEmployee employee;
   2.   employee.SetOld(22);
   3.   int old =employee.GetOld();

    你的伙伴一定会在写代码时诅咒你写了一个垃圾的类。所以你决定要改变这个现状。很幸运，你是MS的忠实用户，而且你对于MSDN看很仔细，所以你知道可以这样来写

1. 1. class CEmployee
   2. {
   3. private:
   4.   int m_old;
   5. public:
   6.  _declspec(property(get= GetOld,put=SetOld))int Old;
   7.  
   8.  int GetOld(void)
   9.  {
   10.   return m_old;
   11.  }
   12.  void SetOld(int value)
   13.  {
   14.   if( (value >0) && (value <60))
   15.   {
   16.   m_old = value;
   17.   }
   18.   else
   19.   {
   20.   m_old =20;
   21.   }
   22.  }
   23. };

     Very Good,上面的类完美地完成一个属性所要做的目标，不过还有一点小问题，象我这样比较笨的经常需要查找MSDN才会知道    

1. 1. _declspec(property(get= GetOld,put=SetOld))int Old;

     这句话的含义，而且我也经常忘记它的具体写法，比如put我常把它写成了set，这总是让我想起了使用C#的美好时光,它是可以写成这个样子的

1. 1. public class CEmployee
   2.  {
   3.   private int m_old;
   4.   public int Old
   5.   {
   6.   get
   7.   { return m_old; }
   8.   set
   9.   {
   10.     if(value >0 && value <60)
   11.     {
   12.         m_old = value;
   13.      }
   14.     else
   15.     {
   16.         m_old =20;
   17.      }
   18.   }
   19.   }
   20.  }

所以我想到可以利用C/C++中强大的武器宏，我们来定义几个宏

1. 1. #define PROP(T,X) __declspec(property(get= __get##X,put= __put##X))T X;
   2. #define GETPROP(T,X) __declspec(property(get= __get##X))T X; //只读属性
   3. #define SETPROP(T,X) __declspec(property(put= __put##X))T X; //只写属必
   4. #define GET(T,X) T __get##X(void) 
   5. #define SET(T,X) void __put##X(T value)

    说明一下：T 代表属性的类型如int,double,CString，而X代表属性名称。如果你需要一个只读属性可以使用GETPROP，只写属性则可以使用SETPORP，然后对应使用一个GET或SET，当然如果你用PROP，而只用了一个GET或SET，也没有错，只是在编译时会告诉你没有一个__getXXX或__putXXX的方法。然后我们就可以这样来写我们的类。

1. 1. class CEmployee
   2. {
   3. private:
   4.   int m_old;
   5. public:
   6.  PROP(int ,Old)
   7.  GET(int,Old)
   8.  {
   9.   return m_old;
   10.  }
   11.  SET(int,Old)
   12.  {
   13.   if( (value >0) && (value <60)) //这里的value你可把它和C#一样当做关键字
   14.   {
   15.   m_old = value;
   16.   }
   17.   else
   18.   {
   19.   m_old =20;
   20.   }
   21.  }
   22. };

    好了，我们要做的工作已经做完了。当然这种方法还是有很多问题，比如不能使用C#中常用的索引属性，静态属性等等。但是毕竟我们是C++程序员么，呵呵！最后，这种方法只是在VC下有用。