以任何编译语言实现以下语法（适用于Factory设计模式）吗？ 最好是Kotlin，C ++

Question

I want to know if the below syntax is available for a compiled langue? Please do not provide java as it requires the JVM. The design is equivalent to a factory design pattern as we initialize a class once some test passes in normal situations we use lots of if-else statements ie When we have a range of classes we ie 10 classes the code becomes clunky I am trying to create a language transpiled or compiled not decided on that yet and would looking into features capabilities of the already compiled languages currently working with kotlin-native and llvm (not yet sorted llvm integration) it's on startup and that is what I want to consider using.

 class A{ } class B extends A{ } class C extends A{ } class D extends A{ } class E extends A{ } class F extends A{ } class G extends A{ } class H extends A{ } class I extends A{ } class J extends A{ } class K extends A{ } function getClass(test){ if(test == 1){ return new B() }else if (test == 2){ return new C() }else if (test == 3){ return new D() }else if (test == 4){ return new E() }else if (test == 5){ return new F() }else if (test == 6){ return new G() }else if (test == 7){ return new H() }else if (test == 8){ return new I() }else if (test == 9){ return new J() }else if (test == 10){ return new K() } } let klass = getClass(10) console.log(`Found class ${klass.constructor.name}`) 

 class A { static test(test) { return test === this.index; } } class B extends A{} B.index = 1 class C extends A{} C.index = 2 class D extends A{} D.index = 3 class E extends A{} E.index = 4 class F extends A{} F.index = 5 class G extends A{} G.index = 6 class H extends A{} H.index = 7 class I extends A{} I.index = 8 class J extends A{} J.index = 9 class K extends A{} K.index = 10 let klasses = [B, C,D,E,F,G,H,I,G,K]; let klass = new A(); let test = 7; for (let i = 0; i < klasses.length; i++) { try { if(klasses[i].test(test)){ klass = new klasses[i]() } } catch (e) { console.log(e) } } console.log(`Found class ${klass.constructor.name}`); 

Answer 1

Can you clarify your question? Your previous question How can I achieve the below syntax in any compiled language? preferably Kotlin, C++ actually seemed clearer to me. Could you maybe give us information on what high-level goal you are trying to achieve?

Are you trying to design a new language? Are you trying to pick a language to implement your new language's parser in?

Going by your code, you are trying to design a language where classes are kept as a list, in order of declaration, and then you want to be able to instantiate all those classes by iterating the list somehow, and the classes are supposed to be able to know their own index in the list for other uses?

Is that what you're trying to do?

In most languages, classes can't be kept in arrays. They aren't actual objects. But some, like Smalltalk, Objective-C, Self or TADS, implicitly create an object for each class that contains additional data (C++ has an atrophied form of this called "runtime type-information", or RTTI).

If your implementation language doesn't do that, you'll have to do that yourself. Create objects that contain a function that creates an object of the right subclass (and maybe contains some other information like the class name or index in the list so you can find it again), and add that "maker" object to a global list. Then just use this global list of factory objects to create your instances.

You're not saying how you are creating your language though. Are you writing a tool that reads a text file in your language and turns it into a source file in an existing language? Then that tool would just have to create the source code for a few additional classes (like, for class B , it would also create a class B_Maker that is a subclass of class A_Maker , but creates a new object of type B , and then it would create some init() function containing code to crete a new object of each maker and add them to the global list).

If you're modifying LLVM or some other existing compiler chain, or trying to do this from scratch, the basic approach would be the same (unless there is already an existing object for each class that you can just extend), but you wouldn't be generating source code, but some other data structures that result in the equivalent code being compiled in the end.

Give us more context, and we might be able to help.