From 5fa43ba405fd10cf5bda52d9d466a3fe3fdbd2b7 Mon Sep 17 00:00:00 2001 From: wolf Date: Tue, 22 Jun 2004 16:09:57 +0000 Subject: [PATCH] Add a class that allows comparing arbitrary pointers. git-svn-id: https://svn.dealii.org/trunk@9451 0785d39b-7218-0410-832d-ea1e28bc413d --- .../base/include/base/template_constraints.h | 70 ++++++++++++++++++- 1 file changed, 69 insertions(+), 1 deletion(-) diff --git a/deal.II/base/include/base/template_constraints.h b/deal.II/base/include/base/template_constraints.h index 381d655adb..23c463e50d 100644 --- a/deal.II/base/include/base/template_constraints.h +++ b/deal.II/base/include/base/template_constraints.h @@ -2,7 +2,7 @@ // $Id$ // Version: $Name$ // -// Copyright (C) 2003 by the deal authors +// Copyright (C) 2003, 2004 by the deal authors // // This file is subject to QPL and may not be distributed // without copyright and license information. Please refer @@ -99,4 +99,72 @@ template struct constraint_and_return_value #endif + +/** + * A class to perform comparisons of arbitrary pointers for equality. In some + * circumstances, one would like to make sure that two arguments to a function + * are not the same object. One would, in this case, make sure that their + * addresses are not the same. However, sometimes the types of these two + * arguments may be template types, and they may be the same type or not. In + * this case, a simple comparison as in &object1 != &object2 does + * only work if the types of the two objects are equal, but the compiler will + * barf if they are not. However, in the latter case, since the types of the + * two objects are different, we can be sure that the two objects cannot be + * the same. + * + * This class implements a comparison function that always returns @p false if + * the types of its two arguments are different, and returns p1 == p2 + * otherwise. + * + * @author Wolfgang Bangerth, 2004 + */ +struct PointerComparison +{ + /** + * Comparison function for pointers of + * the same type. Returns @p true if the + * two pointers are equal. + */ + template + static bool equal (const T *p1, const T *p2); + + /** + * Comparison function for pointers of + * different types. The C++ language does + * not allow comparing these pointers + * using operator==. However, + * since the two pointers have different + * types, we know that they can't be the + * same, so we always return @p false. + */ + template + static bool equal (const T*, const U*); +}; + + + +// --------------- inline functions ----------------- + + +template +inline +bool +PointerComparison::equal (const T*, const U*) +{ + return false; +} + + + +template +inline +bool +PointerComparison::equal (const T *p1, const T *p2) +{ + return (p1==p2); +} + + + + #endif -- 2.39.5