ಟಿ 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
ಎಂಬ ಅಂಶವನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ಕಳೆದುಕೊಳ್ಳುತ್ತದೆಯೇ? ಇಲ್ಲದಿದ್ದರೆ, ಟಿ
ಸ್ವೀಕರಿಸುವ ವಿಧಾನದ ದೃಷ್ಟಿಕೋನದಿಂದ ನಾವು ಜ್ಞಾನವನ್ನು ಹೇಗೆ ಪುನಃ ಪಡೆದುಕೊಳ್ಳುತ್ತೇವೆ?
ಸಾಮಾನ್ಯವಾಗಿ ಮಾತನಾಡಲು:
ಬೇರೆ ರೀತಿಯಲ್ಲಿ ಹೇಳುವುದಾದರೆ, ಒಂದು ಪ್ರಕಾರವು ಇನ್ನೊಂದನ್ನು ಆಧರಿಸಿದ್ದರೆ, ವೇರಿಯಬಲ್ ಆಗಿದ್ದರೆ ಪಡೆದ ಪ್ರಕಾರವನ್ನು ಒಂದು ವಿಧಾನವನ್ನು ಚಲಾಯಿಸಲು ಮೂಲ ಪ್ರಕಾರಕ್ಕೆ ಒತ್ತಾಯಿಸಲಾಗುತ್ತದೆ, ಅದನ್ನು ಕರೆದ ರಿಸೀವರ್ನ ನೈಜ ಪ್ರಕಾರವನ್ನು ಆ ವಿಧಾನವು ಕಲಿಯಬಹುದೇ?