请教高手关于 operator () 操作符？

我想实现一个类似于 C# 的属性，属性自身是没问题的。Int 类自身也没问题，但如果采用模板的方式调用的话会存在问题。我觉得问题的具体细节也许详细描述了，代码中有注明。恳请高手帮忙看看！！！

class Int
{
protected:
    int Value;

public:
    Int();
    Int(const int &value);

    Int& operator= (const int &value);
    operator int const () const;
};

Int::Int()
{
}


Int::Int( const int &value )
{
    Value = value;
}

Int& Int::operator = (const int &value)
{
    Value = value;
    return *this;
}

Int::operator int const () const
{
    return Value;
}


int _tmain(int argc, _TCHAR* argv[])
{
    // Int 隐式转换为 int
    Int n1 = 1;
    int n2 = n1;

    property<Int> Width;
    Width = 10;

    // 此处不支持隐式转换，为什么，该如何处理？
    int k = Width;

	return 0;
}

29 个解决方案

#1

忘了把编译错误贴上来了：error C2440: “初始化”: 无法从“property<T>”转换为“int”

#2

Width是Property<Int>类型，不是Int类型，所以如果int k = Width；编译通过，首先要支持Property<Int>到Int类型的转化，然后才是Int类型到int类型的转化。

#3

嗯，我觉得你说得好像是蛮有道理的，请问这种情况该如何解决呢？

#4

不要瞎折腾属性语法。
语法糖只会把自己绕进去。

#5

引用 2 楼 lulu3212 的回复:

Width是Property<Int>类型，不是Int类型，所以如果int k = Width；编译通过，首先要支持Property<Int>到Int类型的转化，然后才是Int类型到int类型的转化。

++Property<Int>类型 和  int 类型不能作相互类型转换的了！

所以你的代码思路得换一个，

#6

这主要看用在什么地方了，语法糖不一定是坏事，它可以把代码变得很优雅、很简洁。
如果说这都算语法糖的话，那么boost、C++0x花哨的地方比这多多了，难道我们都去排斥他们？
语法糖这种东西也需要作者有足够的功底才能去实习，对自己也是一种考验和提升，难道不是吗？
taodm，你以前曾帮助过我解决一些问题，我很感激您，也知道您是C++方面的高手，只是这个问题我不敢苟同，而且我现在要做的项目中的确需要这个功能。因为在property的 set 和 get 中我需要做一些事情（不是纯粹的 Value = tempValue, return Value）因为我有很多属性，我不可能没用到一个属性都去重复地写一个 propery...

所以，我现在的确需要这个功能。还希望高手们能够帮忙指点一下，多谢了！

#7

引用 5 楼 max_min_ 的回复:

Quote: 引用 2 楼 lulu3212 的回复:

Width是Property<Int>类型，不是Int类型，所以如果int k = Width；编译通过，首先要支持Property<Int>到Int类型的转化，然后才是Int类型到int类型的转化。

++Property<Int>类型 和  int 类型不能作相互类型转换的了！

所以你的代码思路得换一个，

这个问题说来也奇怪，因为 Int 类型是我后加的，我当时使用 _variant_ 去表示通用类型，这时工作是没有任何问题的。但 _variant_ 不支持 RECT、HANDLE 等其它类型，因此也不是足够的通用。所以我采用自定义 Int、Double 等类型的方式，其基类是 Object，此类主要通过 any 来保存任意类型。

这些方面都没问题，现在的问题就是把 _variant_ 换为 Int 就有问题。如果纯粹是因为 Property<Int> 不能转换为 int 的话，那么同样的 Property<_variant_> 为什么可以转换为 int 呢？

#8

property 是怎么实现的？

#9

// 属性定义
template <typename T>
class property
{    
    T value;

public:
    T & operator = (const T &i)
    {
        return value = i;
    }

    operator T const & () const
    {
        return value;
    }
};

这段代码是绝对没问题，用法：
property< int> Width;
Width = 10;
int k = Width;
这些都可以很好的工作。

当然也可以采用 C++ 的 _set 和 _get 来实现，但这种方式会在类内部添加不少成员变量，实现也啰嗦。所以没有采纳。

#10

引用 3 楼 clxye314 的回复:

嗯，我觉得你说得好像是蛮有道理的，请问这种情况该如何解决呢？

1、给property<Int>定义个int的类型转换
2、用一个函数，比如getint() 返回int值，int k = Width.getint();
两种方法选一个。
个人觉得，隐式（1个参数的构造函数）和显式类型转换（operator type），能少用尽量少用。很容易发生在比较的时候变成赋值，错误隐蔽，代码多的话，查找错误的难度增加。用一个明确意义的函数返回转换的值更不容易出错。

#11

引用 10 楼 ananluowei 的回复:

Quote: 引用 3 楼 clxye314 的回复:

嗯，我觉得你说得好像是蛮有道理的，请问这种情况该如何解决呢？

1、给property<Int>定义个int的类型转换
2、用一个函数，比如getint() 返回int值，int k = Width.getint();
两种方法选一个。
个人觉得，隐式（1个参数的构造函数）和显式类型转换（operator type），能少用尽量少用。很容易发生在比较的时候变成赋值，错误隐蔽，代码多的话，查找错误的难度增加。用一个明确意义的函数返回转换的值更不容易出错。

我对您的第一种方法比价感兴趣，也曾考虑过，但不知如何书写 “property<Int>定义个int的类型转换” 这段代码，能明示一下吗？感激不尽！

#12

是我没看明白，还是你忽悠呢。
主楼你说

引用 楼主 clxye314 的回复:

    // 此处不支持隐式转换，为什么，该如何处理？
    int k = Width;

这会儿又说

引用 9 楼 clxye314 的回复:

这段代码是绝对没问题，用法：
property< int> Width;
Width = 10;
int k = Width;
这些都可以很好的工作。

那 int k = Width; 到底是行还是不行？
我试了一下，反正 k = Width 照 #9 的 property 实现是编译错误。另外，property 这样实现就能是 int k = Width; 正确编译了，实际上我觉得还更简单呢。

template <typename T>
struct property : T
{
     T & operator = (const T &i)
     {
      static_cast<T&>(this[0]) = i;
      return this[0];
     }
};

#13

这两个的Int大小写是不一样的，下面的int我还特地用粗体标了一下。
property<Int> Width; // 不可以，Int是我自定义类型
property<int> Width; // 可以，int是C++内置类型。

您的代码只是完成了赋值操作，并且可以返回值。因为我上面的代码只是为了说明问题，所以就把一些不相干的地方去掉了。
实际的代码中是这样的：

// 属性定义
#define Property(DependencyProperty, Type)\
struct\
{\
private:\
    DependencyObject *Object;\
    \
public:\
    void Initialize(DependencyObject *object)\
    {\
        Object = object;\
    }\
    void operator = (const Type &Value)\
    {\
        Object->SetValue(DependencyProperty, Value);\
    }\
    operator Type const () const\
    {\
        return Object->GetValue(DependencyProperty);\
    }\
}

当然，我这边用的是宏，最终用宏或者模板这倒不是重点。

#14

在上个更简单的实现。这么看 Int 本身就支持属性操作，那 property 到底是做什么用的呢。

template <typename T>
struct property : T
{
 using T::operator=;
};

#15

引用 11 楼 clxye314 的回复:

Quote: 引用 10 楼 ananluowei 的回复:

Quote: 引用 3 楼 clxye314 的回复:

嗯，我觉得你说得好像是蛮有道理的，请问这种情况该如何解决呢？

1、给property<Int>定义个int的类型转换
2、用一个函数，比如getint() 返回int值，int k = Width.getint();
两种方法选一个。
个人觉得，隐式（1个参数的构造函数）和显式类型转换（operator type），能少用尽量少用。很容易发生在比较的时候变成赋值，错误隐蔽，代码多的话，查找错误的难度增加。用一个明确意义的函数返回转换的值更不容易出错。

我对您的第一种方法比价感兴趣，也曾考虑过，但不知如何书写 “property<Int>定义个int的类型转换” 这段代码，能明示一下吗？感激不尽！

给你的类模板加个成员函数
operator Type () const {return xxx;} //xxx 是Type类型的变量

#16

引用 13 楼 clxye314 的回复:

这两个的Int大小写是不一样的，下面的int我还特地用粗体标了一下。
property<Int> Width; // 不可以，Int是我自定义类型
property<int> Width; // 可以，int是C++内置类型。

您的代码只是完成了赋值操作，并且可以返回值。因为我上面的代码只是为了说明问题，所以就把一些不相干的地方去掉了。
实际的代码中是这样的：

// 属性定义
#define Property(DependencyProperty, Type)\
struct\
{\
private:\
    DependencyObject *Object;\
    \
public:\
    void Initialize(DependencyObject *object)\
    {\
        Object = object;\
    }\
    void operator = (const Type &Value)\
    {\
        Object->SetValue(DependencyProperty, Value);\
    }\
    operator Type const () const\
    {\
        return Object->GetValue(DependencyProperty);\
    }\
}

当然，我这边用的是宏，最终用宏或者模板这倒不是重点。

啊，你说的对，那是我自己没看明白。

#17

vc 扩展

// declspec_property.cpp
struct S {
   int i;
   void putprop(int j) { 
      i = j;
   }

   int getprop() {
      return i;
   }

   __declspec(property(get = getprop, put = putprop)) int the_prop;
};

int main() {
   S s;
   s.the_prop = 5;
   return s.the_prop;
}

#18

引用 13 楼 clxye314 的回复:

这两个的Int大小写是不一样的，下面的int我还特地用粗体标了一下。
property<Int> Width; // 不可以，Int是我自定义类型
property<int> Width; // 可以，int是C++内置类型。

您的代码只是完成了赋值操作，并且可以返回值。因为我上面的代码只是为了说明问题，所以就把一些不相干的地方去掉了。
实际的代码中是这样的：

// 属性定义
#define Property(DependencyProperty, Type)\
struct\
{\
private:\
    DependencyObject *Object;\
    \
public:\
    void Initialize(DependencyObject *object)\
    {\
        Object = object;\
    }\
    void operator = (const Type &Value)\
    {\
        Object->SetValue(DependencyProperty, Value);\
    }\
    operator Type const () const\
    {\
        return Object->GetValue(DependencyProperty);\
    }\
}

当然，我这边用的是宏，最终用宏或者模板这倒不是重点。

说实话还是没看明白你到底要干什么。我猜你好像是要写一个 property 类，能够自动管理其他类，替其他类实现赋值和类型转换的功能，间接调用被管理类的 SetValue/GetValue 函数。如果是这样的话，下面的实现就行。

template <typename DependencyObject>
struct property
{
private:
    DependencyObject* Object;
    using type = decltype(Object->GetValue());

public:
    property (DependencyObject*const object) : Object(object) { }

    void operator = (const type& Value)
    {
        Object->SetValue(Value);
    }
    operator type const () const
    {
        return Object->GetValue();
    }
};

class Int
{
protected:
    int Value;

public:
    Int() { }
    Int(const int &value) : Value(value) { }

    void SetValue (int const& x)
    {
     Value = x;
    }
    int GetValue () const
    {
     return Value;
    }
};

int main ()
{
    Int a;
    property<Int> Width(&a);
    Width = 10;
    int k = Width;
    std::cout << k << std::endl;
}

#19

嗯，mujiok2003 所说的就是 C++ 的 put 和 get 方法，当时最初也是想用这种方式的，后来觉得在自动提示的时候会多出好多变量，不够简洁，所以放弃了。

如果前面的方式真有问题的话，我只能再次尝试看看，谢谢 mujiok2003。待会我会把结果和大家共享一下。

#20

ri_aje：我对您的想法非常感兴趣，您对我的意图理解是真确定，我主要是在仿 WPF 的依赖项实现。关键字 decltype 以前的确没听过，更没用过。我的开发环境是VS2010+Win7。

我先按照您的思路试试看（对我自己来说好像有点困难），如果是在实现不了的话，希望您能再给予一些指点！
感谢各位朋友对此话题的关心，以及对我的帮助!

#21

引用 20 楼 clxye314 的回复:

ri_aje：我对您的想法非常感兴趣，您对我的意图理解是真确定，我主要是在仿 WPF 的依赖项实现。关键字 decltype 以前的确没听过，更没用过。我的开发环境是VS2010+Win7。

我先按照您的思路试试看（对我自己来说好像有点困难），如果是在实现不了的话，希望您能再给予一些指点！
感谢各位朋友对此话题的关心，以及对我的帮助!

decltype 是新标准里的，如果你的编译器不支持，还可以用下面的方法，总之很多路可以走啦，而且不需要编译器扩展。

template <typename DependencyObject>
struct property
{
private:
    DependencyObject* Object;

public:
    property (DependencyObject*const object) : Object(object) { }

    template <typename T>
    void operator = (const T& Value)
    {
        Object->SetValue(Value);
    }
    template <typename T>
    operator T const () const
    {
        return Object->GetValue();
    }
};

class Int
{
protected:
    int Value;

public:
    Int() { }
    Int(const int &value) : Value(value) { }

    void SetValue (int const& x)
    {
     Value = x;
    }
    int GetValue () const
    {
     return Value;
    }
};

struct test_t
{
};

int main ()
{
    Int a;
    property<Int> Width(&a);
    Width = 10;
    int k = Width; // ok, because Int supports conversion to int.
    std::cout << k << std::endl;

    test_t b = Width; // bad, because Int does not convert to test_t.
}

#22

使用type_traits

#include <iostream>
class Int
{

public:
	explicit  Int(int value = 0) : Value(value) { }

	operator int() const
	{
		return Value;
	}

	operator int&()
	{
		return Value;
	}
	typedef int value_type;
protected:	
	int Value;

};

template<typename T>
class property
{
public:
	explicit property(T const & t = T()): v(t){}
	explicit property(typename T::value_type vt): v(vt){}

	property& operator = (typename T::value_type lhs)
	{
		(typename T::value_type&)v = lhs;
		return *this;
	}

	operator typename T::value_type () const 
	{
		return (typename T::value_type&)v;
	}

	property& operator = (T const &t)
	{
        v = t;
		return *this;
	}

	property& operator = (property const & p)
	{
        (typename T::value_type&)v = (typename T::value_type)t;
		return *this;
	}


private:
	T v;
};

int main ()
{
	property<Int> a;
	std::cout << a << std::endl;
	a = 10;
	std::cout << a << std::endl;
}

#23

楼主以为类型转换支持二级跳吗？先从 property 到 Int，再到 int ？
还是把 property 的 value 公开出来用吧。

#24

#include <iostream>

template <typename DependencyObject>
struct property
{
private:
    DependencyObject Object;

public:
    property() {}
    //property() = default; //this is a better choice,1 : easier to read, 2 : able to make your class "trivial"

    property (DependencyObject const &object) : Object(object) { }

    void operator=(typename DependencyObject::value_type const &Value)
    {
        Object.SetValue(Value);
    }

    void operator=(DependencyObject const &Value)
    {
        Object = Value;
    }

    operator typename DependencyObject::value_type const () const
    {
        return Object.GetValue();
    }
};

class Int
{
protected:
    int Value;

public:
    typedef int value_type;//if compiler support, I would use decltype in property class rather using typedef
    Int() {}
    Int(const int &value) : Value(value) { }

    void SetValue (int const& x)
    {
        Value = x;
    }

    int GetValue () const
    {
        return Value;
    }
};

int main()
{
    property<Int> a(1000);
    std::cout << a << std::endl;
    a = 10;
    std::cout << a << std::endl;
    Int b(100);
    a = b;
    std::cout << a << std::endl;

    return 0;
}

#25

引用 4 楼 taodm 的回复:

不要瞎折腾属性语法。
语法糖只会把自己绕进去。

++1

#26

该回复于2013-08-12 08:40:01被管理员删除

#27

引用 25 楼 ganpengjin1 的回复:

Quote: 引用 4 楼 taodm 的回复:

不要瞎折腾属性语法。
语法糖只会把自己绕进去。

++1

++

已接近于c语言的方式来使用C++。

#28

语法糖越甜，编译调试查错越苦！

#29

谢谢各位这么热心，特别是 max_min_、ri_aje、ananluowei、mujiok2003、stereoMatching。
我最终采用了 stereoMatching 兄弟的做法，因为他的做法和我的有点类似，我的改动很少而且也是我想要的。
再次谢谢各位！