Longueur maximale d'une tranche en Aller

J'ai le code suivant s'exécute dans un linux 64-bit OS 4go machine:

package main

import (
    "fmt"
    "math"
)

func main() {
    r := make([]bool, math.MaxInt32)

    fmt.Println("Size: ", len(r))
}

Lorsque je l'exécute j'obtiens:

Size: 2147483647

Si je change le math.MaxInt32 pour math.MaxUint32 j'obtiens:

fatal error: runtime: out of memory

Avec la taille de la tranche de math.MaxUint32 j'ai couru hors de la mémoire, je m'attendais à ça, mais quand j'ai essayer d'utiliser math.MaxInt64 j'obtiens:

panic: runtime error: makeslice: len out of range

Donc aparently je ne peux pas créer une tranche avec une taille de math.MaxInt64, ce qui nous amène à ma question: Si la mémoire n'est pas un problème, ce qui est la part la plus importante que je ne peux pas créer de Go?

Je me souviens que, en Java, en matières index de tableau sont gérés avec le type int, de sorte que la taille maximale d'un raw de tableau est la valeur max d'un int, si vous essayez de le faire avec long, il déclenche une exception (comme je me souviens bien), est-il de même au rendez-vous? sont de la tranche d'index en Aller lié à un type spécifique?

EDIT:

J'ai couru le test à l'aide de struct{} au lieu de bool et de l'allocation de math.MaxInt64 éléments. Tout se passe comme prévu, et imprime:

Size: 9223372036854775807

Alors, une autre question, pourquoi il y a deux différents messages d'erreur lorsqu'il semble que l'erreur est la même (pas assez de mémoire)?

Quelles sont les conditions pour chaque erreur de la pop?

Il semble donc que c'est une question de message d'erreur ambiguïté, rien de plus... 🙂

OriginalL'auteur Simón Oroño | 2014-12-25

go slice

12

Selon les docs, The elements can be addressed by integer indices 0 through len(s)-1. Cela signifie que la capacité maximale d'une tranche de la taille de la valeur par défaut entier sur la cible de construire.

EDIT: en regardant le code source, il semble qu'il existe un contrôle de sécurité pour s'assurer que la taille de la tranche est possible:
```
func makeslice(t *slicetype, len64 int64, cap64 int64) sliceStruct {
    //NOTE: The len > MaxMem/elemsize check here is not strictly necessary,
    //but it produces a 'len out of range' error instead of a 'cap out of range' error
    //when someone does make([]T, bignumber). 'cap out of range' is true too,
    //but since the cap is only being supplied implicitly, saying len is clearer.
    //See issue 4085.
    len := int(len64)
    if len64 < 0 || int64(len) != len64 || t.elem.size > 0 && uintptr(len) > maxmem/uintptr(t.elem.size) {
        panic(errorString("makeslice: len out of range"))
    }
```
Donc dans ce cas, il ressemble à uintptr(len) > maxmem/uintptr(t.elem.size) donc nous ne sommes pas autorisés à faire de la taille d'une allocation.

Cependant, quand je allouer struct{} qui prend pas de mémoire, cette taille est permis:
```
func main(){
    r := make([]struct{}, math.MaxInt64)
    fmt.Println(len(r))
}
//prints 9223372036854775807
```
Je suis sûr que je dirige 64 bits Aller, si je ne go version il imprime go version go1.4 linux/amd64
ce n' go env d'impression pour GOARCH?
J'ai regardé le code source d'Aller, et je pense que je sais de la question. La mise à jour de ma réponse.
amd64. J'ai couru le test à l'aide struct{} et a eu de mise à jour de la question. S'il vous plaît vérifier 🙂 @Not_a_Golfer
actualiser et de le modifier.

OriginalL'auteur Not_a_Golfer

Vous devez vous connecter pour publier un commentaire.