Existe-t-il un moyen plus rapide / plus court d'initialiser des variables dans une structure Rust?

Dans l'exemple suivant, je préférerais de loin attribuer une valeur à chaque champ de la structure dans la déclaration des champs. Sinon, il faut en fait une instruction supplémentaire pour chaque champ pour attribuer une valeur aux champs. Tout ce que je veux être en mesure de faire est d'assigner des valeurs par défaut lorsque la structure est instanciée.

Existe-t-il une manière plus succincte de procéder?

struct cParams {
    iInsertMax: i64,
    iUpdateMax: i64,
    iDeleteMax: i64,
    iInstanceMax: i64,
    tFirstInstance: bool,
    tCreateTables: bool,
    tContinue: bool,
}

impl cParams {
    fn new() -> cParams {
        cParams {
            iInsertMax: -1,
            iUpdateMax: -1,
            iDeleteMax: -1,
            iInstanceMax: -1,
            tFirstInstance: false,
            tCreateTables: false,
            tContinue: false,
        }
    }
}

Vous pouvez fournir des valeurs par défaut pour votre structure en implémentant le Defaulttrait. La defaultfonction ressemblerait à votre newfonction actuelle :

impl Default for cParams {
    fn default() -> cParams {
        cParams {
            iInsertMax: -1,
            iUpdateMax: -1,
            iDeleteMax: -1,
            iInstanceMax: -1,
            tFirstInstance: false,
            tCreateTables: false,
            tContinue: false,
        }
    }
}

Vous pouvez ensuite instancier la structure en ne donnant que les valeurs non par défaut:

let p = cParams { iInsertMax: 10, ..Default::default() };

Avec quelques modifications mineures de votre structure de données, vous pouvez tirer parti d'une implémentation par défaut dérivée automatiquement. Si vous utilisez #[derive(Default)]sur une structure de données, le compilateur créera automatiquement une fonction par défaut pour vous qui remplit chaque champ avec sa valeur par défaut. La valeur booléenne par défaut est false, la valeur intégrale par défaut est 0.

La valeur par défaut d'un entier étant 0 est un problème ici car vous voulez que les champs entiers soient -1 par défaut. Vous pouvez définir un nouveau type qui implémente une valeur par défaut de -1 et l'utiliser au lieu de i64dans votre structure. (Je n'ai pas testé cela, mais cela devrait fonctionner).

Cependant, je suggère de modifier légèrement votre structure de données et d'utiliser à la Option<i64>place de i64. Je ne connais pas le contexte de votre code, mais il semble que vous utilisiez la valeur spéciale de -1 pour représenter la signification spéciale "infini" ou "il n'y a pas de max". Dans Rust, nous utilisons un Optionpour représenter une valeur actuelle facultative. Il n'y a pas besoin d'un hack -1. Une option peut être soit Noneou Some(x)où x serait votre i64ici. Il peut même s'agir d'un entier non signé si -1 était la seule valeur négative. La Optionvaleur par défaut est None, donc avec les modifications proposées, votre code pourrait ressembler à ceci:

#[derive(Default)]
struct cParams {
    iInsertMax: Option<u64>,
    iUpdateMax: Option<u64>,
    iDeleteMax: Option<u64>,
    iInstanceMax: Option<u64>,
    tFirstInstance: bool,
    tCreateTables: bool,
    tContinue: bool,
}

let p = cParams { iInsertMax: Some(10), ..Default::default() };