Ist es möglich, globale Variablen in Rust zu verwenden?

Ich weiß, dass im Allgemeinen, Globale Variablen sind zu vermeiden. Trotzdem denke ich, im praktischen Sinne, ist es manchmal wünschenswert, (in Situationen, in denen die variable ist integraler Bestandteil des Programms), Sie zu verwenden.

Um zu lernen, Rost, Schreibe ich momentan ein Datenbank-test-Programm mit sqlite3 und die Rost - /sqlite3-Paket auf GitHub. Folglich erfordert, dass (in meinem test-Programm) (als alternative zu einer globalen variable), vorbei an der Datenbank variable zwischen Funktionen, von denen es etwa ein Dutzend. Ein Beispiel ist unten.

Ist es möglich und machbar und wünschenswert, die Verwendung von globalen Variablen in Rust?
Gegeben, wie das Beispiel unten kann ich erklären, und verwenden Sie eine Globale variable?

extern crate sqlite;

fn main() {
    let db: sqlite::Connection = open_database();

    if !insert_data(&db, insert_max) {
        return;
    }
}

Ich habe Folgendes versucht, aber es scheint nicht ganz richtig und führte in der unten stehenden Fehlerliste (ich habe versucht, auch mit einer unsafe block):

extern crate sqlite;

static mut DB: Option<sqlite::Connection> = None;

fn main() {
    DB = sqlite::open("test.db").expect("Error opening test.db");
    println!("Database Opened OK");

    create_table();
    println!("Completed");
}

//Create Table
fn create_table() {
    let sql = "CREATE TABLE IF NOT EXISTS TEMP2 (ikey INTEGER PRIMARY KEY NOT NULL)";
    match DB.exec(sql) {
        Ok(_) => println!("Table created"),
        Err(err) => println!("Exec of Sql failed : {}\nSql={}", err, sql),
    }
}

Fehler führte kompilieren:

error[E0308]: mismatched types
 --> src/main.rs:6:10
  |
6 |     DB = sqlite::open("test.db").expect("Error opening test.db");
  |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected enum `std::option::Option`, found struct `sqlite::Connection`
  |
  = note: expected type `std::option::Option<sqlite::Connection>`
             found type `sqlite::Connection`

error: no method named `exec` found for type `std::option::Option<sqlite::Connection>` in the current scope
  --> src/main.rs:16:14
   |
16 |     match DB.exec(sql) {
   |              ^^^^

InformationsquelleAutor der Frage Brian Oh | 2013-10-26

global-variables rust

Es ist möglich, aber keine heap erlaubt direkt. Heap wird zur Laufzeit erfolgen. Hier sind einige Beispiele:

static SOME_INT: i32 = 5;
static SOME_STR: &'static str = "A static string";
static SOME_STRUCT: MyStruct = MyStruct {
    number: 10,
    string: "Some string",
};
static mut db: Option<sqlite::Connection> = None;

fn main() {
    println!("{}", SOME_INT);
    println!("{}", SOME_STR);
    println!("{}", SOME_STRUCT.number);
    println!("{}", SOME_STRUCT.string);

    unsafe {
        db = Some(open_database());
    }
}

struct MyStruct {
    number: i32,
    string: &'static str,
}

InformationsquelleAutor der Antwort Ercan Erden

13

Sie können statische Variablen relativ einfach, solange Sie sind thread-lokale.

Der Nachteil ist, dass das Objekt nicht sichtbar sein, zu anderen threads, die dein Programm vielleicht laichen. Der Vorteil ist, dass im Gegensatz zu wirklich globalen Status, es ist völlig sicher und ist nicht ein Schmerz zu verwenden - true global state ist eine massive pain in any language. Hier ist ein Beispiel:
```
extern mod sqlite;

use std::cell::RefCell;

thread_local!(static ODB: RefCell<sqlite::database::Database> = RefCell::new(sqlite::open("test.db"));

fn main() {
    ODB.with(|odb_cell| {
        let odb = odb_cell.borrow_mut();
        //code that uses odb goes here
    });
}
```
Hier erstellen wir eine thread-lokale statische Variablen zu, und verwenden Sie dann in einer Funktion. Beachten Sie, dass es statisch ist und unveränderlich; das heißt, dass die Adresse, an der es sich befindet, ist unveränderlich, aber Dank RefCell den Wert selbst verändert werden.

Im Gegensatz zu normalen static im thread-local!(static ...) können Sie erstellen, die so ziemlich beliebige Objekte, einschließlich denen, die erfordern heap-Zuweisungen für die Initialisierung wie VecHashMap und andere.

Wenn Sie nicht initialisiert den Wert sofort, z.B. hängt es von Benutzereingaben, können Sie auch werfen Option gibt, in welchem Fall Zugriff auf, wird es etwas unhandlich:
```
extern mod sqlite;

use std::cell::RefCell;

thread_local!(static ODB: RefCell<Option<sqlite::database::Database>> = RefCell::New(None));

fn main() {
    ODB.with(|odb_cell| {
        //assumes the value has already been initialized, panics otherwise
        let odb = odb_cell.borrow_mut().as_mut().unwrap();
        //code that uses odb goes here
    });
}
```
InformationsquelleAutor der Antwort Shnatsel
11

Blick auf die const und static - Abschnitt der Rost Buch.

Können Sie etwas wie folgt:
```
const N: i32 = 5; 
```
oder
```
static N: i32 = 5;
```
im globalen Raum.

Diese sind aber nicht veränderbar. Für Veränderlichkeit, könnten Sie so etwas wie:
```
static mut N: i32 = 5;
```
Dann verweisen Sie gerne:
```
unsafe {
    N += 1;

    println!("N: {}", N);
}
```
InformationsquelleAutor der Antwort AbbasFaisal

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.