ಒಂದು ಪ್ರಕಾರವನ್ನು ಇನ್ನೊಂದಕ್ಕೆ ಒತ್ತಾಯಿಸಲಾಗುತ್ತದೆ, ರಿಸೀವರ್‌ನ ಪ್ರಕಾರವನ್ನು ನಿರ್ಧರಿಸಲು ಒಂದು ವಿಧಾನವನ್ನು ಮಾಡಬಹುದೇ?

ಟಿ 1 ಮತ್ತು ಟಿ 2 ಪ್ರಕಾರಗಳು ಟಿ ಪ್ರಕಾರವನ್ನು ಆಧರಿಸಿದ್ದರೆ, ಮತ್ತು ಟಿ . 1199268] ಟಿ 1 ಅಥವಾ ಟಿ 2 ?

package main
import "fmt"
import "reflect"

type T struct { s string }
func (v *T) WhoAmI() string {

        // pull type name with reflect  
        fmt.Println( reflect.TypeOf(v).Elem().Name() )  // always prints "T"!

        // todo: if I am actually T1
        return "T1"
        // todo: else if I am actually T2
        return "T2"
}

type T1 T
func NewT1( s string ) T1 { return T1{ s } }

type T2 T
func NewT2( s string ) T2 { return T2{ s } }

func main() {
        var t1 = T1{ "xyz" }
        var t2 = T2{ "pdq" }
        s1 := ((*T)(&t1)).WhoAmI()      // would like to return "T1"
        s2 := ((*T)(&t2)).WhoAmI()      // would like to return "T2"
        fmt.Println( s1, s2 )
}

ತಾಂತ್ರಿಕವಾಗಿ ಮಾತನಾಡಲು:

ಒಮ್ಮೆ ಟಿ 1 ಪ್ರಕಾರ ಟಿ 1 ಅನ್ನು ಟಿ ಆದ್ದರಿಂದ ಫನ್ಕ್ (* ಟಿ) ಹೂಆಮಿ () ಅನ್ನು ಕರೆಯಬಹುದು, ಟಿ 1 ಅದರ ಪ್ರಕಾರವು ನಿಜವಾಗಿಯೂ ಟಿ 1 ಎಂಬ ಅಂಶವನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ಕಳೆದುಕೊಳ್ಳುತ್ತದೆಯೇ? ಇಲ್ಲದಿದ್ದರೆ, ಟಿ ಸ್ವೀಕರಿಸುವ ವಿಧಾನದ ದೃಷ್ಟಿಕೋನದಿಂದ ನಾವು ಜ್ಞಾನವನ್ನು ಹೇಗೆ ಪುನಃ ಪಡೆದುಕೊಳ್ಳುತ್ತೇವೆ?

ಸಾಮಾನ್ಯವಾಗಿ ಮಾತನಾಡಲು:

ಬೇರೆ ರೀತಿಯಲ್ಲಿ ಹೇಳುವುದಾದರೆ, ಒಂದು ಪ್ರಕಾರವು ಇನ್ನೊಂದನ್ನು ಆಧರಿಸಿದ್ದರೆ, ವೇರಿಯಬಲ್ ಆಗಿದ್ದರೆ ಪಡೆದ ಪ್ರಕಾರವನ್ನು ಒಂದು ವಿಧಾನವನ್ನು ಚಲಾಯಿಸಲು ಮೂಲ ಪ್ರಕಾರಕ್ಕೆ ಒತ್ತಾಯಿಸಲಾಗುತ್ತದೆ, ಅದನ್ನು ಕರೆದ ರಿಸೀವರ್‌ನ ನೈಜ ಪ್ರಕಾರವನ್ನು ಆ ವಿಧಾನವು ಕಲಿಯಬಹುದೇ?

5
задан Flimzy 25 November 2019 в 21:45
поделиться