l0n0lc 0.3.2__py3-none-any.whl → 0.4.0__py3-none-any.whl

l0n0lc/c/345/237/272/347/241/200/347/261/273/345/236/213.py

@@ -1,209 +1,670 @@
 
 from .c类型基础 import c类型基础
+from .c域 import 输出
 
 class i8(c类型基础):
     类型名 = 'int8_t'
 
-class i8_p(c类型基础):
+class i8引用(c类型基础):
+    类型名 = 'int8_t&'    
+    
+class i8指针(c类型基础):
     类型名 = f'int8_t*'
-
-class i8_p_p(c类型基础):
+    def __init__(self, 容量 = 0, 初始值 = []):
+        self.容量 = 容量
+        self.初始值 = 初始值
+        初始值字符串 = '{' + ','.join(初始值) + '}'
+        super().__init__(初始值字符串)
+
+    def 生成初始值字符串(self):
+        self.初始化字符串 = f'= {self.初始值}'
+        if len(self.初始值) == 0:
+            self.初始化字符串 = ''
+
+    def 输出定义(self):
+        if self.容量 == 0:
+            输出(f'{self.类型名称()} {self.变量名} {self.初始化字符串};\n')
+        else:
+            输出(f'{self.类型名称()} {self.变量名}[{self.容量}] {self.初始化字符串};\n')
+            
+        
+class i8指针的指针(c类型基础):
     类型名 = f'int8_t**'    
 
 class i16(c类型基础):
     类型名 = 'int16_t'
 
-class i16_p(c类型基础):
+class i16引用(c类型基础):
+    类型名 = 'int16_t&'    
+    
+class i16指针(c类型基础):
     类型名 = f'int16_t*'
-
-class i16_p_p(c类型基础):
+    def __init__(self, 容量 = 0, 初始值 = []):
+        self.容量 = 容量
+        self.初始值 = 初始值
+        初始值字符串 = '{' + ','.join(初始值) + '}'
+        super().__init__(初始值字符串)
+
+    def 生成初始值字符串(self):
+        self.初始化字符串 = f'= {self.初始值}'
+        if len(self.初始值) == 0:
+            self.初始化字符串 = ''
+
+    def 输出定义(self):
+        if self.容量 == 0:
+            输出(f'{self.类型名称()} {self.变量名} {self.初始化字符串};\n')
+        else:
+            输出(f'{self.类型名称()} {self.变量名}[{self.容量}] {self.初始化字符串};\n')
+            
+        
+class i16指针的指针(c类型基础):
     类型名 = f'int16_t**'    
 
 class i32(c类型基础):
     类型名 = 'int32_t'
 
-class i32_p(c类型基础):
+class i32引用(c类型基础):
+    类型名 = 'int32_t&'    
+    
+class i32指针(c类型基础):
     类型名 = f'int32_t*'
-
-class i32_p_p(c类型基础):
+    def __init__(self, 容量 = 0, 初始值 = []):
+        self.容量 = 容量
+        self.初始值 = 初始值
+        初始值字符串 = '{' + ','.join(初始值) + '}'
+        super().__init__(初始值字符串)
+
+    def 生成初始值字符串(self):
+        self.初始化字符串 = f'= {self.初始值}'
+        if len(self.初始值) == 0:
+            self.初始化字符串 = ''
+
+    def 输出定义(self):
+        if self.容量 == 0:
+            输出(f'{self.类型名称()} {self.变量名} {self.初始化字符串};\n')
+        else:
+            输出(f'{self.类型名称()} {self.变量名}[{self.容量}] {self.初始化字符串};\n')
+            
+        
+class i32指针的指针(c类型基础):
     类型名 = f'int32_t**'    
 
 class i64(c类型基础):
     类型名 = 'int64_t'
 
-class i64_p(c类型基础):
+class i64引用(c类型基础):
+    类型名 = 'int64_t&'    
+    
+class i64指针(c类型基础):
     类型名 = f'int64_t*'
-
-class i64_p_p(c类型基础):
+    def __init__(self, 容量 = 0, 初始值 = []):
+        self.容量 = 容量
+        self.初始值 = 初始值
+        初始值字符串 = '{' + ','.join(初始值) + '}'
+        super().__init__(初始值字符串)
+
+    def 生成初始值字符串(self):
+        self.初始化字符串 = f'= {self.初始值}'
+        if len(self.初始值) == 0:
+            self.初始化字符串 = ''
+
+    def 输出定义(self):
+        if self.容量 == 0:
+            输出(f'{self.类型名称()} {self.变量名} {self.初始化字符串};\n')
+        else:
+            输出(f'{self.类型名称()} {self.变量名}[{self.容量}] {self.初始化字符串};\n')
+            
+        
+class i64指针的指针(c类型基础):
     类型名 = f'int64_t**'    
 
 class u8(c类型基础):
     类型名 = 'uint8_t'
 
-class u8_p(c类型基础):
+class u8引用(c类型基础):
+    类型名 = 'uint8_t&'    
+    
+class u8指针(c类型基础):
     类型名 = f'uint8_t*'
-
-class u8_p_p(c类型基础):
+    def __init__(self, 容量 = 0, 初始值 = []):
+        self.容量 = 容量
+        self.初始值 = 初始值
+        初始值字符串 = '{' + ','.join(初始值) + '}'
+        super().__init__(初始值字符串)
+
+    def 生成初始值字符串(self):
+        self.初始化字符串 = f'= {self.初始值}'
+        if len(self.初始值) == 0:
+            self.初始化字符串 = ''
+
+    def 输出定义(self):
+        if self.容量 == 0:
+            输出(f'{self.类型名称()} {self.变量名} {self.初始化字符串};\n')
+        else:
+            输出(f'{self.类型名称()} {self.变量名}[{self.容量}] {self.初始化字符串};\n')
+            
+        
+class u8指针的指针(c类型基础):
     类型名 = f'uint8_t**'    
 
 class u16(c类型基础):
     类型名 = 'uint16_t'
 
-class u16_p(c类型基础):
+class u16引用(c类型基础):
+    类型名 = 'uint16_t&'    
+    
+class u16指针(c类型基础):
     类型名 = f'uint16_t*'
-
-class u16_p_p(c类型基础):
+    def __init__(self, 容量 = 0, 初始值 = []):
+        self.容量 = 容量
+        self.初始值 = 初始值
+        初始值字符串 = '{' + ','.join(初始值) + '}'
+        super().__init__(初始值字符串)
+
+    def 生成初始值字符串(self):
+        self.初始化字符串 = f'= {self.初始值}'
+        if len(self.初始值) == 0:
+            self.初始化字符串 = ''
+
+    def 输出定义(self):
+        if self.容量 == 0:
+            输出(f'{self.类型名称()} {self.变量名} {self.初始化字符串};\n')
+        else:
+            输出(f'{self.类型名称()} {self.变量名}[{self.容量}] {self.初始化字符串};\n')
+            
+        
+class u16指针的指针(c类型基础):
     类型名 = f'uint16_t**'    
 
 class u32(c类型基础):
     类型名 = 'uint32_t'
 
-class u32_p(c类型基础):
+class u32引用(c类型基础):
+    类型名 = 'uint32_t&'    
+    
+class u32指针(c类型基础):
     类型名 = f'uint32_t*'
-
-class u32_p_p(c类型基础):
+    def __init__(self, 容量 = 0, 初始值 = []):
+        self.容量 = 容量
+        self.初始值 = 初始值
+        初始值字符串 = '{' + ','.join(初始值) + '}'
+        super().__init__(初始值字符串)
+
+    def 生成初始值字符串(self):
+        self.初始化字符串 = f'= {self.初始值}'
+        if len(self.初始值) == 0:
+            self.初始化字符串 = ''
+
+    def 输出定义(self):
+        if self.容量 == 0:
+            输出(f'{self.类型名称()} {self.变量名} {self.初始化字符串};\n')
+        else:
+            输出(f'{self.类型名称()} {self.变量名}[{self.容量}] {self.初始化字符串};\n')
+            
+        
+class u32指针的指针(c类型基础):
     类型名 = f'uint32_t**'    
 
 class u64(c类型基础):
     类型名 = 'uint64_t'
 
-class u64_p(c类型基础):
+class u64引用(c类型基础):
+    类型名 = 'uint64_t&'    
+    
+class u64指针(c类型基础):
     类型名 = f'uint64_t*'
-
-class u64_p_p(c类型基础):
+    def __init__(self, 容量 = 0, 初始值 = []):
+        self.容量 = 容量
+        self.初始值 = 初始值
+        初始值字符串 = '{' + ','.join(初始值) + '}'
+        super().__init__(初始值字符串)
+
+    def 生成初始值字符串(self):
+        self.初始化字符串 = f'= {self.初始值}'
+        if len(self.初始值) == 0:
+            self.初始化字符串 = ''
+
+    def 输出定义(self):
+        if self.容量 == 0:
+            输出(f'{self.类型名称()} {self.变量名} {self.初始化字符串};\n')
+        else:
+            输出(f'{self.类型名称()} {self.变量名}[{self.容量}] {self.初始化字符串};\n')
+            
+        
+class u64指针的指针(c类型基础):
     类型名 = f'uint64_t**'    
 
 class bf16(c类型基础):
     类型名 = 'bfloat16_t'
 
-class bf16_p(c类型基础):
+class bf16引用(c类型基础):
+    类型名 = 'bfloat16_t&'    
+    
+class bf16指针(c类型基础):
     类型名 = f'bfloat16_t*'
-
-class bf16_p_p(c类型基础):
+    def __init__(self, 容量 = 0, 初始值 = []):
+        self.容量 = 容量
+        self.初始值 = 初始值
+        初始值字符串 = '{' + ','.join(初始值) + '}'
+        super().__init__(初始值字符串)
+
+    def 生成初始值字符串(self):
+        self.初始化字符串 = f'= {self.初始值}'
+        if len(self.初始值) == 0:
+            self.初始化字符串 = ''
+
+    def 输出定义(self):
+        if self.容量 == 0:
+            输出(f'{self.类型名称()} {self.变量名} {self.初始化字符串};\n')
+        else:
+            输出(f'{self.类型名称()} {self.变量名}[{self.容量}] {self.初始化字符串};\n')
+            
+        
+class bf16指针的指针(c类型基础):
     类型名 = f'bfloat16_t**'    
 
 class f16(c类型基础):
     类型名 = 'half'
 
-class f16_p(c类型基础):
+class f16引用(c类型基础):
+    类型名 = 'half&'    
+    
+class f16指针(c类型基础):
     类型名 = f'half*'
-
-class f16_p_p(c类型基础):
+    def __init__(self, 容量 = 0, 初始值 = []):
+        self.容量 = 容量
+        self.初始值 = 初始值
+        初始值字符串 = '{' + ','.join(初始值) + '}'
+        super().__init__(初始值字符串)
+
+    def 生成初始值字符串(self):
+        self.初始化字符串 = f'= {self.初始值}'
+        if len(self.初始值) == 0:
+            self.初始化字符串 = ''
+
+    def 输出定义(self):
+        if self.容量 == 0:
+            输出(f'{self.类型名称()} {self.变量名} {self.初始化字符串};\n')
+        else:
+            输出(f'{self.类型名称()} {self.变量名}[{self.容量}] {self.初始化字符串};\n')
+            
+        
+class f16指针的指针(c类型基础):
     类型名 = f'half**'    
 
 class f32(c类型基础):
     类型名 = 'float'
 
-class f32_p(c类型基础):
+class f32引用(c类型基础):
+    类型名 = 'float&'    
+    
+class f32指针(c类型基础):
     类型名 = f'float*'
-
-class f32_p_p(c类型基础):
+    def __init__(self, 容量 = 0, 初始值 = []):
+        self.容量 = 容量
+        self.初始值 = 初始值
+        初始值字符串 = '{' + ','.join(初始值) + '}'
+        super().__init__(初始值字符串)
+
+    def 生成初始值字符串(self):
+        self.初始化字符串 = f'= {self.初始值}'
+        if len(self.初始值) == 0:
+            self.初始化字符串 = ''
+
+    def 输出定义(self):
+        if self.容量 == 0:
+            输出(f'{self.类型名称()} {self.变量名} {self.初始化字符串};\n')
+        else:
+            输出(f'{self.类型名称()} {self.变量名}[{self.容量}] {self.初始化字符串};\n')
+            
+        
+class f32指针的指针(c类型基础):
     类型名 = f'float**'    
 
 class f64(c类型基础):
     类型名 = 'double'
 
-class f64_p(c类型基础):
+class f64引用(c类型基础):
+    类型名 = 'double&'    
+    
+class f64指针(c类型基础):
     类型名 = f'double*'
-
-class f64_p_p(c类型基础):
+    def __init__(self, 容量 = 0, 初始值 = []):
+        self.容量 = 容量
+        self.初始值 = 初始值
+        初始值字符串 = '{' + ','.join(初始值) + '}'
+        super().__init__(初始值字符串)
+
+    def 生成初始值字符串(self):
+        self.初始化字符串 = f'= {self.初始值}'
+        if len(self.初始值) == 0:
+            self.初始化字符串 = ''
+
+    def 输出定义(self):
+        if self.容量 == 0:
+            输出(f'{self.类型名称()} {self.变量名} {self.初始化字符串};\n')
+        else:
+            输出(f'{self.类型名称()} {self.变量名}[{self.容量}] {self.初始化字符串};\n')
+            
+        
+class f64指针的指针(c类型基础):
     类型名 = f'double**'    
 
 class boolean(c类型基础):
     类型名 = 'bool'
 
-class boolean_p(c类型基础):
+class boolean引用(c类型基础):
+    类型名 = 'bool&'    
+    
+class boolean指针(c类型基础):
     类型名 = f'bool*'
-
-class boolean_p_p(c类型基础):
+    def __init__(self, 容量 = 0, 初始值 = []):
+        self.容量 = 容量
+        self.初始值 = 初始值
+        初始值字符串 = '{' + ','.join(初始值) + '}'
+        super().__init__(初始值字符串)
+
+    def 生成初始值字符串(self):
+        self.初始化字符串 = f'= {self.初始值}'
+        if len(self.初始值) == 0:
+            self.初始化字符串 = ''
+
+    def 输出定义(self):
+        if self.容量 == 0:
+            输出(f'{self.类型名称()} {self.变量名} {self.初始化字符串};\n')
+        else:
+            输出(f'{self.类型名称()} {self.变量名}[{self.容量}] {self.初始化字符串};\n')
+            
+        
+class boolean指针的指针(c类型基础):
     类型名 = f'bool**'    
 
 class char(c类型基础):
     类型名 = 'char'
 
-class char_p(c类型基础):
+class char引用(c类型基础):
+    类型名 = 'char&'    
+    
+class char指针(c类型基础):
     类型名 = f'char*'
-
-class char_p_p(c类型基础):
+    def __init__(self, 容量 = 0, 初始值 = []):
+        self.容量 = 容量
+        self.初始值 = 初始值
+        初始值字符串 = '{' + ','.join(初始值) + '}'
+        super().__init__(初始值字符串)
+
+    def 生成初始值字符串(self):
+        self.初始化字符串 = f'= {self.初始值}'
+        if len(self.初始值) == 0:
+            self.初始化字符串 = ''
+
+    def 输出定义(self):
+        if self.容量 == 0:
+            输出(f'{self.类型名称()} {self.变量名} {self.初始化字符串};\n')
+        else:
+            输出(f'{self.类型名称()} {self.变量名}[{self.容量}] {self.初始化字符串};\n')
+            
+        
+class char指针的指针(c类型基础):
     类型名 = f'char**'    
 
 class uchar(c类型基础):
     类型名 = 'unsigned char'
 
-class uchar_p(c类型基础):
+class uchar引用(c类型基础):
+    类型名 = 'unsigned char&'    
+    
+class uchar指针(c类型基础):
     类型名 = f'unsigned char*'
-
-class uchar_p_p(c类型基础):
+    def __init__(self, 容量 = 0, 初始值 = []):
+        self.容量 = 容量
+        self.初始值 = 初始值
+        初始值字符串 = '{' + ','.join(初始值) + '}'
+        super().__init__(初始值字符串)
+
+    def 生成初始值字符串(self):
+        self.初始化字符串 = f'= {self.初始值}'
+        if len(self.初始值) == 0:
+            self.初始化字符串 = ''
+
+    def 输出定义(self):
+        if self.容量 == 0:
+            输出(f'{self.类型名称()} {self.变量名} {self.初始化字符串};\n')
+        else:
+            输出(f'{self.类型名称()} {self.变量名}[{self.容量}] {self.初始化字符串};\n')
+            
+        
+class uchar指针的指针(c类型基础):
     类型名 = f'unsigned char**'    
 
 class int(c类型基础):
     类型名 = 'int'
 
-class int_p(c类型基础):
+class int引用(c类型基础):
+    类型名 = 'int&'    
+    
+class int指针(c类型基础):
     类型名 = f'int*'
-
-class int_p_p(c类型基础):
+    def __init__(self, 容量 = 0, 初始值 = []):
+        self.容量 = 容量
+        self.初始值 = 初始值
+        初始值字符串 = '{' + ','.join(初始值) + '}'
+        super().__init__(初始值字符串)
+
+    def 生成初始值字符串(self):
+        self.初始化字符串 = f'= {self.初始值}'
+        if len(self.初始值) == 0:
+            self.初始化字符串 = ''
+
+    def 输出定义(self):
+        if self.容量 == 0:
+            输出(f'{self.类型名称()} {self.变量名} {self.初始化字符串};\n')
+        else:
+            输出(f'{self.类型名称()} {self.变量名}[{self.容量}] {self.初始化字符串};\n')
+            
+        
+class int指针的指针(c类型基础):
     类型名 = f'int**'    
 
 class uint(c类型基础):
     类型名 = 'unsigned int'
 
-class uint_p(c类型基础):
+class uint引用(c类型基础):
+    类型名 = 'unsigned int&'    
+    
+class uint指针(c类型基础):
     类型名 = f'unsigned int*'
-
-class uint_p_p(c类型基础):
+    def __init__(self, 容量 = 0, 初始值 = []):
+        self.容量 = 容量
+        self.初始值 = 初始值
+        初始值字符串 = '{' + ','.join(初始值) + '}'
+        super().__init__(初始值字符串)
+
+    def 生成初始值字符串(self):
+        self.初始化字符串 = f'= {self.初始值}'
+        if len(self.初始值) == 0:
+            self.初始化字符串 = ''
+
+    def 输出定义(self):
+        if self.容量 == 0:
+            输出(f'{self.类型名称()} {self.变量名} {self.初始化字符串};\n')
+        else:
+            输出(f'{self.类型名称()} {self.变量名}[{self.容量}] {self.初始化字符串};\n')
+            
+        
+class uint指针的指针(c类型基础):
     类型名 = f'unsigned int**'    
 
 class short(c类型基础):
     类型名 = 'short'
 
-class short_p(c类型基础):
+class short引用(c类型基础):
+    类型名 = 'short&'    
+    
+class short指针(c类型基础):
     类型名 = f'short*'
-
-class short_p_p(c类型基础):
+    def __init__(self, 容量 = 0, 初始值 = []):
+        self.容量 = 容量
+        self.初始值 = 初始值
+        初始值字符串 = '{' + ','.join(初始值) + '}'
+        super().__init__(初始值字符串)
+
+    def 生成初始值字符串(self):
+        self.初始化字符串 = f'= {self.初始值}'
+        if len(self.初始值) == 0:
+            self.初始化字符串 = ''
+
+    def 输出定义(self):
+        if self.容量 == 0:
+            输出(f'{self.类型名称()} {self.变量名} {self.初始化字符串};\n')
+        else:
+            输出(f'{self.类型名称()} {self.变量名}[{self.容量}] {self.初始化字符串};\n')
+            
+        
+class short指针的指针(c类型基础):
     类型名 = f'short**'    
 
 class ushort(c类型基础):
     类型名 = 'unsigned short'
 
-class ushort_p(c类型基础):
+class ushort引用(c类型基础):
+    类型名 = 'unsigned short&'    
+    
+class ushort指针(c类型基础):
     类型名 = f'unsigned short*'
-
-class ushort_p_p(c类型基础):
+    def __init__(self, 容量 = 0, 初始值 = []):
+        self.容量 = 容量
+        self.初始值 = 初始值
+        初始值字符串 = '{' + ','.join(初始值) + '}'
+        super().__init__(初始值字符串)
+
+    def 生成初始值字符串(self):
+        self.初始化字符串 = f'= {self.初始值}'
+        if len(self.初始值) == 0:
+            self.初始化字符串 = ''
+
+    def 输出定义(self):
+        if self.容量 == 0:
+            输出(f'{self.类型名称()} {self.变量名} {self.初始化字符串};\n')
+        else:
+            输出(f'{self.类型名称()} {self.变量名}[{self.容量}] {self.初始化字符串};\n')
+            
+        
+class ushort指针的指针(c类型基础):
     类型名 = f'unsigned short**'    
 
 class long(c类型基础):
     类型名 = 'long'
 
-class long_p(c类型基础):
+class long引用(c类型基础):
+    类型名 = 'long&'    
+    
+class long指针(c类型基础):
     类型名 = f'long*'
-
-class long_p_p(c类型基础):
+    def __init__(self, 容量 = 0, 初始值 = []):
+        self.容量 = 容量
+        self.初始值 = 初始值
+        初始值字符串 = '{' + ','.join(初始值) + '}'
+        super().__init__(初始值字符串)
+
+    def 生成初始值字符串(self):
+        self.初始化字符串 = f'= {self.初始值}'
+        if len(self.初始值) == 0:
+            self.初始化字符串 = ''
+
+    def 输出定义(self):
+        if self.容量 == 0:
+            输出(f'{self.类型名称()} {self.变量名} {self.初始化字符串};\n')
+        else:
+            输出(f'{self.类型名称()} {self.变量名}[{self.容量}] {self.初始化字符串};\n')
+            
+        
+class long指针的指针(c类型基础):
     类型名 = f'long**'    
 
 class ulong(c类型基础):
     类型名 = 'unsigned long'
 
-class ulong_p(c类型基础):
+class ulong引用(c类型基础):
+    类型名 = 'unsigned long&'    
+    
+class ulong指针(c类型基础):
     类型名 = f'unsigned long*'
-
-class ulong_p_p(c类型基础):
+    def __init__(self, 容量 = 0, 初始值 = []):
+        self.容量 = 容量
+        self.初始值 = 初始值
+        初始值字符串 = '{' + ','.join(初始值) + '}'
+        super().__init__(初始值字符串)
+
+    def 生成初始值字符串(self):
+        self.初始化字符串 = f'= {self.初始值}'
+        if len(self.初始值) == 0:
+            self.初始化字符串 = ''
+
+    def 输出定义(self):
+        if self.容量 == 0:
+            输出(f'{self.类型名称()} {self.变量名} {self.初始化字符串};\n')
+        else:
+            输出(f'{self.类型名称()} {self.变量名}[{self.容量}] {self.初始化字符串};\n')
+            
+        
+class ulong指针的指针(c类型基础):
     类型名 = f'unsigned long**'    
 
 class longlong(c类型基础):
     类型名 = 'long long'
 
-class longlong_p(c类型基础):
+class longlong引用(c类型基础):
+    类型名 = 'long long&'    
+    
+class longlong指针(c类型基础):
     类型名 = f'long long*'
-
-class longlong_p_p(c类型基础):
+    def __init__(self, 容量 = 0, 初始值 = []):
+        self.容量 = 容量
+        self.初始值 = 初始值
+        初始值字符串 = '{' + ','.join(初始值) + '}'
+        super().__init__(初始值字符串)
+
+    def 生成初始值字符串(self):
+        self.初始化字符串 = f'= {self.初始值}'
+        if len(self.初始值) == 0:
+            self.初始化字符串 = ''
+
+    def 输出定义(self):
+        if self.容量 == 0:
+            输出(f'{self.类型名称()} {self.变量名} {self.初始化字符串};\n')
+        else:
+            输出(f'{self.类型名称()} {self.变量名}[{self.容量}] {self.初始化字符串};\n')
+            
+        
+class longlong指针的指针(c类型基础):
     类型名 = f'long long**'    
 
 class ulonglong(c类型基础):
     类型名 = 'unsigned long long'
 
-class ulonglong_p(c类型基础):
+class ulonglong引用(c类型基础):
+    类型名 = 'unsigned long long&'    
+    
+class ulonglong指针(c类型基础):
     类型名 = f'unsigned long long*'
-
-class ulonglong_p_p(c类型基础):
+    def __init__(self, 容量 = 0, 初始值 = []):
+        self.容量 = 容量
+        self.初始值 = 初始值
+        初始值字符串 = '{' + ','.join(初始值) + '}'
+        super().__init__(初始值字符串)
+
+    def 生成初始值字符串(self):
+        self.初始化字符串 = f'= {self.初始值}'
+        if len(self.初始值) == 0:
+            self.初始化字符串 = ''
+
+    def 输出定义(self):
+        if self.容量 == 0:
+            输出(f'{self.类型名称()} {self.变量名} {self.初始化字符串};\n')
+        else:
+            输出(f'{self.类型名称()} {self.变量名}[{self.容量}] {self.初始化字符串};\n')
+            
+        
+class ulonglong指针的指针(c类型基础):
     类型名 = f'unsigned long long**'    

{l0n0lc-0.3.2.dist-info → l0n0lc-0.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: l0n0lc
-Version: 0.3.2
+Version: 0.4.0
 Summary: 用python写c
 Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.10

{l0n0lc-0.3.2.dist-info → l0n0lc-0.4.0.dist-info}/RECORD

@@ -1,13 +1,13 @@
 l0n0lc/__init__.py,sha256=FdeyabIdYOFtX2TGIfMfOv43Q7qiEdSvY3oclyzEom8,280
 l0n0lc/c域.py,sha256=iJXbsmI7jpM4THHSxRGBmUbHeOhBSEk8Js25Ri0wN98,3602
-l0n0lc/c基础类型.py,sha256=6Ec41ormG9VfOVvXgGBHELIOG_Gw22PKnnmLUMSPNLA,4185
+l0n0lc/c基础类型.py,sha256=eSKeDGg2r1i4g6AcMCXC2bAL_5-ooksRzv6fsYs2zyE,21967
 l0n0lc/c类型基础.py,sha256=FmHGKICEkRm4mnUmqqf-PDF2yUg91mzBdJjq07L6e8k,8471
 l0n0lc/c语句.py,sha256=1KuFjBpONO_MWTwQUxa14GFOp1yddPKsY-3-41qGe5Q,1506
 l0n0lc/utils.py,sha256=6OTdWdfwKIAqicSRTFmw-DYLn1xZv-JHC7J9aQffFZQ,1287
 l0n0lc/编译.py,sha256=mN5UoKCuNrUtJYn7cFkU5iSzmMdr8vw8Cz80kiOyZ3w,1971
 l0n0lc/输出.py,sha256=vJ-9cQ9U41-m4oyrDmhSWpsJG8FNtChm4sJ75Fy3m00,317
-l0n0lc-0.3.2.dist-info/licenses/LICENSE,sha256=1L-MAjulZ3kpbYwsJtlXpDVITRxykna2Ecg_521YfkA,1093
-l0n0lc-0.3.2.dist-info/METADATA,sha256=6wk-kiGqMKIH3dVvz5--RCbsm9PQDzmoXtraK9kRvqU,2128
-l0n0lc-0.3.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-l0n0lc-0.3.2.dist-info/top_level.txt,sha256=Q21D_eEY_-xgRUPwATGp9YDKSBO4w_7MI2MYxQI1aT4,7
-l0n0lc-0.3.2.dist-info/RECORD,,
+l0n0lc-0.4.0.dist-info/licenses/LICENSE,sha256=1L-MAjulZ3kpbYwsJtlXpDVITRxykna2Ecg_521YfkA,1093
+l0n0lc-0.4.0.dist-info/METADATA,sha256=rQR7nEJUID-ez9wScIxdX4uns0Qt56uJ4QWP_GPk59U,2128
+l0n0lc-0.4.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+l0n0lc-0.4.0.dist-info/top_level.txt,sha256=Q21D_eEY_-xgRUPwATGp9YDKSBO4w_7MI2MYxQI1aT4,7
+l0n0lc-0.4.0.dist-info/RECORD,,