Est-ce que C ++ a un mot clé "avec" comme Pascal?

with mot-clé dans Pascal peut être utiliser pour un accès rapide le champ d'un enregistrement.
Quelqu'un sait si C++ a quelque chose de semblable à cela?

Ex:
J'ai un pointeur à de nombreux domaines et je ne veux pas de type comme ceci:

if (pointer->field1) && (pointer->field2) && ... (pointer->fieldn)

ce que je veux vraiment, c'est quelque chose comme ça en C++:

with (pointer)
{
  if (field1) && (field2) && .......(fieldn)
}

source d'informationauteur root

  1. 11

    En C++, vous pouvez mettre le code dans une méthode de la classe de référence par pointer. Vous pouvez y faire référence directement aux membres, sans l'aide du pointeur. Faire inline et vous bien obtenir ce que vous voulez.

  2. 18

    Probablement le plus proche que vous pouvez obtenir est ceci: (Merci de ne pas downvote pour moi, c'est juste un exercice académique. Bien sûr, vous ne pouvez pas utiliser des variables locales dans le corps de ces artificiel with blocs!)

    struct Bar {
    int field;
};

void foo( Bar &b ) {
    struct withbar : Bar { void operator()() {
        cerr << field << endl;
    }}; static_cast<withbar&>(b)();
}

    Ou, un peu plus diaboliquement,

    #define WITH(T) do { struct WITH : T { void operator()() {
#define ENDWITH(X) }}; static_cast<WITH&>((X))(); } while(0)

struct Bar {
    int field;
};

void foo( Bar &b ) {
    if ( 1+1 == 2 )
        WITH( Bar )
            cerr << field << endl;
        ENDWITH( b );
}

    ou en C++0x

    #define WITH(X) do { auto P = &X; \
 struct WITH : typename decay< decltype(X) >::type { void operator()() {
#define ENDWITH }}; static_cast<WITH&>((*P))(); } while(0)

        WITH( b )
            cerr << field << endl;
        ENDWITH;
  3. 11

    non, il n'est pas tel mot-clé.

  4. 8

    Même si je programme principalement en Delphi qui a un with mot-clé (depuis Delphi est un Pascal dérivés), je n'utilise pas with. Comme d'autres l'ont dit: il permet d'économiser un peu sur le typage, mais la lecture est rendue plus difficile.

    Dans un cas comme le code ci-dessous il peut être tentant d'utiliser with:

    cxGrid.DBTableView.ViewData.Records.FieldByName('foo').Value = 1;
cxGrid.DBTableView.ViewData.Records.FieldByName('bar').Value = 2;
cxGrid.DBTableView.ViewData.Records.FieldByName('baz').Value = 3;

    À l'aide de with cela ressemble à ce

    with cxGrid.DBTableView.ViewData.Records do
begin
  FieldByName('foo').Value = 1;
  FieldByName('bar').Value = 2;
  FieldByName('baz').Value = 3;
end;

    Je préfère utiliser une technique différente, par l'introduction d'une variable supplémentaire pointant vers la même chose with serait pointant vers. Comme ceci:

    var lRecords: TDataSet;

lRecords := cxGrid.DBTableView.ViewData.Records;

lRecords.FieldByName('foo').Value = 1;
lRecords.FieldByName('bar').Value = 2;
lRecords.FieldByName('baz').Value = 3;

    De cette façon, il n'y a pas d'ambiguïté, vous économiser un peu sur le typage et le but du code est plus clair que l'utilisation de with

  5. 8

    J'aime utiliser:

        #define BEGIN_WITH(x) { \
        auto &_ = x;

    #define END_WITH() }

    Exemple:

        BEGIN_WITH(MyStructABC)
    _.a = 1;
    _.b = 2;
    _.c = 3;
    END_WITH()
  6. 5

    Non, C++ n'a pas de mot-clé.

  7. 5

    C++ n'a pas de fonctionnalité. Et beaucoup le considèrent comme "AVEC" en Pascal d'être un problème, car il peut rendre le code ambigu et difficile à lire, par exemple, il est difficile de savoir si champ1 est un membre de pointeur ou une variable locale ou quelque chose d'autre. Pascal permet aussi de multiples avec des variables telles que "Avec Var1,Var2" ce qui rend encore plus difficile.

  8. 3

    Le plus proche que vous pouvez obtenir est le chaînage de méthode:

    myObj->setX(x)
     ->setY(y)
     ->setZ(z)

    pour l'établissement de plusieurs champs et using pour les espaces de noms.

  9. 1

    Première fois que j'ai entendu dire que quelqu'un n'aime pas "avec". Les règles sont parfaitement simple, pas différent de ce qui se passe à l'intérieur d'une classe en C++ ou en Java. Et ne pas oublier qu'il peut entraîner une importante optimisation du compilateur.

  10. 1

    Avoir écrit de nombreux analyseurs, cela semble être une simple liste de chercher de l'objet nommé, soit statique ou dynamique. De plus, je n'ai jamais vu une situation où le compilateur n'a pas d'identifier correctement l'objet manquant et le type, de sorte que toutes ces mauvaises excuses pour ne pas permettre une AVEC ...ENDWITH construction semble être beaucoup de hooey. Pour le reste d'entre nous sujettes à la longue des noms d'objet, une solution de contournement consiste à créer de simples définit. N'a pas pu résister, supposons que j'ai:

        #include<something> 
    typedef int headache;
    class grits{
      public:
       void corn(void);
       void cattle(void);
       void hay(void);}; //insert function defs here
     void grits::grits(void)(printf("Welcome to Farm-o-mania 2012\n");};

    #define m mylittlepiggy_from_under_the_backporch.
    headache main(){
       grits mylittlepiggy_from_under_the_backporch;
         m corn();  //works in GCC
         m cattle();
         m hay();
      return headache;
  11. 1
    with (OBJECT) {CODE}

    Il n'y a pas une telle chose en C++.

    Vous pouvez mettre le CODE comme c'est dans une méthode de l'OBJET, mais il n'est pas toujours souhaitable.

    Avec C++11, vous pouvez obtenir assez proche, par la création d'alias avec le nom de l'OBJET.

    Par exemple, le code donné dans la question elle ressemble à:

    {
    auto &_ = *pointer;
    if (_.field1 && ... && _.fieldn) {...}
}

    (L'entourant les accolades sont utilisées pour limiter la visibilité de alias _ )

    Si vous utilisez un champ très souvent, vous pouvez alias directement:

    auto &field = pointer->field;
//Even shorter alias:
auto &_ = pointer->busy_field;
  12. 0

    L'approche suivante s'appuie sur un coup de pouce. Si votre compilateur prend en charge le C++0x du auto ensuite, vous pouvez l'utiliser et de se débarrasser de la poussée de la dépendance.

    Avertissement: merci de ne pas le faire dans n'importe quel code qui doit être maintenue ou lu par quelqu'un d'autre (ou même par vous-même dans quelques mois):

    #define WITH(src_var)                                             \
    if(int cnt_ = 1)                                              \
        for(BOOST_AUTO(const & _, src_var); cnt_; --cnt_)


int main()
{
    std::string str = "foo";

    //Multiple statement block
    WITH(str)
    {
        int i = _.length();
        std::cout << i << "\n";
    }

    //Single statement block
    WITH(str)
        std::cout << _ << "\n";

    //Nesting
    WITH(str)
    {
        std::string another("bar");
        WITH(another)
            assert(_ == "bar");
    }
}
  13. 0

    Je peux voir un exemple où "avec" est en fait utile.

    Dans les méthodes pour les structures de données, vous avez souvent le cas:

    void A::method()
{
  for (A* node = this; node; node = node->next) {
    abc(node->value1);
    def(value2); //-- oops should have been node->value2
    xyz(node->value3);
  }
}

    les erreurs causées par les fautes de ce genre sont très difficiles à trouver.

    Avec la "avec la" on pourrait écrire

    void A::method()
{
  for (A* node = this; node; node = node->next) with (node) {
    abc(value1);
    def(value2);
    xyz(value3);
  }
}

    Ce qui ne doit pas dépasser tous les autres négatifs mentionnés pour "avec", mais juste une info intéressante...

  14. 0

    Peut-être vous pouvez:

    auto p = *pointer;
if (p.field1) && (p.field2) && ... (p.fieldn)

    Ou de créer un petit programme qui va comprendre with de déclarations en C++ et les traduire en une forme valide de C++.