Faire tous les types Constante par défaut dans C ++

Question

Quelle est la plus simple et la moins importune pour indiquer au compilateur, que ce soit au moyen d'options compilateur, #defines, typedefs ou modèles, que chaque fois que je dis T, je T const que cela signifie vraiment? Je préférerais ne pas utiliser un préprocesseur externe. Comme je ne ce serait pas utiliser le mot-clé mutable, acceptable pour reformater pour indiquer l'état mutable.

Modifier Étant donné que l'intention de ce se trompait tout (et puisque je n'y étais pas pendant quelques heures pour clarifier), laissez-moi vous expliquer. Essentiellement, je veux juste savoir ce que les systèmes sont disponibles pour manipuler le système de type à la compilation. Je ne me soucie pas si cela crée non standard, mauvais inmaintenable, le code inutile. Je ne vais pas l'utiliser dans la production. Il est juste une curiosité.

Les solutions possibles (de) suboptimales jusqu'à présent:

// I presume redefinition of keywords is implementation-defined or illegal.
#define int int const
#define ptr * const
int i(0);
int ptr j(&i);

typedef int const Int;
typedef int const* const Intp;
Int i(0);
Intp j(&i);

template<class T>
struct C { typedef T const type; typedef T const* const ptr; };
C<int>::type i(0);
C<int>::ptr j(&i);

Answer 1

Prenez une open source compilateur C ++ et le modifier.

Je pense que la raison principale de la downvotes est que les gens pensent que vous essayez de modifier C ++. Dites-leur plutôt que vous créez une nouvelle langue appelée « C-const » comme un projet universitaire.

Personnellement, je pense que c'est une idée intéressante - vous pouvez gagner toutes sortes de gains de performance et de lisibilité de types immuables -. Il suffit de regarder la plupart des langages fonctionnels

Answer 2

Même si vous êtes en mesure de le faire (que je suppose que vous n'êtes pas), pensez à d'autres personnes qui lisent votre code. Ils ne sont pas susceptibles de comprendre que tout est const et par conséquent ne sont pas susceptibles de comprendre votre code.

Answer 3

Vous essayez de dire au compilateur, ou dire aux autres personnes qui lisent ou en utilisant votre code? Le compilateur ne fera pas très différent de quoi que ce soit juste parce que un type défini par l'utilisateur est utilisé const. Vraiment, tout ce qu'il fait est de changer l'ensemble des méthodes (définies ou implicites utilisateur) qui peuvent être utilisés avec cet objet. À son tour, que peut permet au compilateur de déduire certaines optimisations sur la représentation de l'exécution.

Pour les types class / struct, vous pouvez le préciser à la fois le compilateur et les utilisateurs en faisant simplement tous les membres const:

class Point {
    // An immutable Point data object
    public:
        Point(int ix, int iy): x(ix), y(iy) { }
        Point(const Point& p): x(p.x), y(p.y) { }

        Point add(const Point& p) const;
        int taxiDistance() const;
        // etc... all const members

        const int x, y; // const can only be init'd at construction time

     private:
        Point& operator=(const Point& p); // never implemented!
}

Answer 4

Je vous conseille contre cela. Si vous parvenez à vous atteindre quelqu'un de but (vous y compris après un certain temps) est surpris quand il lit votre code et il se comporte différent de celui qu'il attend.

S'il vous plaît ajouter le visible const simple modificateur pour tout le monde partout où il est nécessaire. Votre code va être lu le plus souvent prix alors il va être écrit!

Answer 5

Vous pouvez conserver le code C ++ standard et concevoir une couche supplémentaire de vérification de type.

Une macro mutables vide pourrait servir d'indice pour le const checker . Explicit Const peut encore être nécessaire à des endroits pour faire la compilation de code.