关于C语言，我喜欢和讨厌的十件事

u010402865

yulihua49 发表于 2013-11-25 14:21
这不，问题来了：
http://bbs.chinaunix.net/thread-4112117-1-1.html

这个问题很好解决啊，我在前面也说了，以结构体大小为单元写入二进制文件，读取时再以结构体大小为单元读到结构体变量里就行啊。如果担心不同系统的字节对齐差异，就用#pragma pack设置为同样的字节对齐。

yulihua49

u010402865 发表于 2013-11-25 14:55
这个问题很好解决啊，我在前面也说了，以结构体大小为单元写入二进制文件，读取时再以结构体大小为单元 ...

还是改在这里讨论把：
跨平台只是举个例子，还有方方面面的工作与通用结构处理有关。
你用数据库吗？对每个SQL语句都要做一大套类似的繁琐的操作，反感吗？
如果每个SQL语句都对应一个结构，里边有结果集变量，查询条件变量，要插入或修改数据库的变量，用一个公用的程序处理这些变量是不是会方便许多？
那么这个公用程序怎么写呢？他怎么知道你结构里有啥？SQL语句里哪个变量对应结构的哪个变量？这个又需要反射了。
看看我这个帖，虽然挨了不少骂，但是工作进展到现在是极为成功的。
http://www.itpub.net/thread-1088197-1-1.html
将数据库的使用简化到极致，性能也高到极致。

boyatchinaunix

yulihua49 发表于 2013-11-13 12:22
转帖的吧？
最有感触的是：C没有反射。

只要在struct 的固定位置包含一个函数指针即可，很容易实现的。

typedef *struct2json_fun(void *);

typedef
struct stA
{
    void * struct2json_fun;
    int var1;
    int var2;
} A;

typedef
struct stB
{
    void * struct2json_fun;
    int var3;
    int var4;
} B;

char * A2json(A* a)
{
     ....;
}

A* createA()
{
     A *p = malloc(sizeof(A));
    p->struct2json_fun= A2json;
    return p;
}


char * B2json(B* a)
{
     ....;
}

B* createB()
{
     B *p = malloc(sizeof(B));
    p->struct2json_fun= B2json;
    return p;
}

char * struct2json(void * st)
{
     struct2json_fun p = *(struct2json_fun *)st;
     return p(st);
}

u010402865

yulihua49 发表于 2013-11-25 19:55
如果每个SQL语句都对应一个结构，里边有结果集变量，查询条件变量，要插入或修改数据库的变量，用一个公用的程序处理这些变量是不是会方便许多？
那么这个公用程序怎么写呢？他怎么知道你结构里有啥？SQL语句里哪个变量对应结构的哪个变量？这个又需要反射了。 ...

不合理的需求导致蹩脚的设计。把SQL语句再用结构体封装，有这个必要么？看你的这个需求，我认你应该好好考虑用函数把SQL语句封装，而不是用结构体和所谓的反射。

yulihua49

boyatchinaunix 发表于 2013-11-25 21:39
只要在struct 的固定位置包含一个函数指针即可，很容易实现的。

typedef *struct2json_fun(void *); ...

可以啊，面向对象。
但是，这形不成通用程序，依然是每种结构两个程序，一个序列化，一个反序列化。
如果只是简单的按成员处理，未尝不可。

但是，复杂的，如与SQL互相映射，这个法子等于没有给用户任何帮助。（你没有提供通用的SQL处理解决方案，还是每个都自己写）。

下题，你怎么做：

1.         for(rows=0;!ferror(ifd);rows++) {
   
2.                 fgets(buf,buflen,ifd);//读出一行
   
3.                 if(feof(ifd)) break;
   
4.                  ret=DAU_pkg_dispack(&_DAU,buf,dlmt);//反序列化到DAU里的struct
   
5.                 *buf=0;
   
6.                 ret=DAU_insert(&_DAU,buf);// 将数据插入数据库，buf用于产生SQL语句
   
7. //......
   

复制代码

那个插入数据库的函数，你怎么做？
数据库表是运行时指定的，文件是与之匹配的。

yulihua49

u010402865 发表于 2013-11-26 10:32
不合理的需求导致蹩脚的设计。把SQL语句再用结构体封装，有这个必要么？看你的这个需求，我认你应该好好 ...

这个值得讨论。
SQL面对的不是一个数据，是二维数据集，由行和列组成。
他的处理比较繁琐。我们希望能够写一组通用处理，能够处理任何表和多表的SQL。
这些个函数，你不可能使用离散的变量在函数内外传递数据。因为你连运行时人家用那个表，那个语句，要多少变量都不知道。
例如，楼上的那个DAU_insert,它是要绑定变量的，哪个表？有多少变量？各什么类型，多大，在哪？
所以，要使用集合型数据接口。
C有哪些集合型数据？一个数组，一个结构，你说用哪种接口？
参照JAVA的Hibernate，一个ORM，建议你了解一下这个东东。它采用Object接口，Object，其实就是扩展的struct。
数据库，读出来是要用的，你用struct接口，就很方便，就跟你说的二进制文件接口一样，读出即可用。
其实当年所想，跟你是一模一样的，像读写记录文件一样的读写数据库。
现在，我做到了。
那个DAU_insert,与write，是否异曲同工？这个需求不合理妈？
实际上，那个DAU，Data Access Unit，就是把模板和结构组装在一起，你理解，就是一个可反射的结构。
看看上贴的4,6行，反射，方便吗，设计，蹩脚吗？
前边给你的链接就是它的开发历程。没有提及内部例程，太多，太复杂。有反射，何至于此？
此后，我们，所有的关于数据库的应用项目，一律DAU，再也不用写SQL语句了。
方便快捷的开发效率，和几近极限的运行效率，使我们受益匪浅。

yulihua49

u010402865 发表于 2013-11-26 10:32
不合理的需求导致蹩脚的设计。把SQL语句再用结构体封装，有这个必要么？看你的这个需求，我认你应该好好 ...

给你看一个我最近的项目，还没有完的。
把一个，你所说的，包装SQL的应用，改造成DAU的应用。
原因是，原来的性能太低，内存泄漏，不能移植到其他数据库。新的解决这3个问题。
注释的部分是原来的程序，可对比一下：

1. bool CDataParameter::loadCardType()
   
2. {
   
3. CD_YKT_APPLICATION_MODE_stu rec;
   
4. CD_YKT_FARE_CARD_TYPE_stu f_rec;
   
5. int ret;
   
6. char stmt[4096],*p;
   
7. DAU q_DAU,f_DAU;
   
8. 
   
9.         DAU_init(&q_DAU,m_DbConnect,NULL,&rec,CD_YKT_APPLICATION_MODE_tpl);//把结构和模板组装在一起，形成可反射的‘对象’
   
10.         DAU_init(&f_DAU,m_DbConnect,NULL,&f_rec,CD_YKT_FARE_CARD_TYPE_tpl);
    
11. /*
    
12.         //输出调试信息
    
13.           CsVerbose("Begin ApplicationMode:     %s\n", "");//KTH 20101005 增加提示信息
    
14.         CsDebug( YKT_DBG_CONN, ( YKT_DBG_CONN, "Query table:     '%s'.\n", "CD_YKT_APPLICATION_MODE" ) );
    
15. 
    
16.         //查询数据
    
17.         std::ostringstream sql;
    
18.         sql     << "SELECT t.MODE_ID FROM afc_cd.CD_YKT_APPLICATION_MODE t "
    
19.                 << AppendWhere()
    
20.                 << "ORDER BY t.MODE_ID ASC";
    
21.         StructuredQuery q("CD_YKT_APPLICATION_MODE");
    
22.         StructuredQueryResultset r;
    
23. 
    
24.         add_column<SQUInt>              ("MODE_ID", q);
    
25. 
    
26.         do_query(sql.str().c_str(), q, r, *(GetConnect()->datasource()));//,GetSid());
    
27. 
    
28.         if(r.size() > 0)
    
29.         {
    
30.                 for(StructuredQuery* row = r.getFirstRow(); row; row = r.getNextRow())
    
31.                 {
    
32.                         DataApplicationMode ApplicationMode;
    
33.                         ApplicationMode.modeID = extract<uint32, SQUInt>(row->getFirstColumn());
    
34. 
    
35.                         //根据每一个ModeID,继续查询数据
    
36.                         CsDebug( YKT_DBG_CONN, ( YKT_DBG_CONN, "Query table:     '%s'.\n", "CD_YKT_FARE_CARD_TYPE" ) );
    
37.                         std::ostringstream sqlCardType;
    
38.                         sql.str("");
    
39.                         sql     << "SELECT t.CARD_PHYSICAL_TYPE, t.CARD_LOGICAL_TYPE, t.CARD_TYPE_NAME, t.CARD_ATTRIBUTE FROM afc_cd.CD_YKT_FARE_CARD_TYPE t "
    
40.                                 << AppendWhere();
    
41. 
    
42.                         StructuredQuery qCardType("CD_YKT_FARE_CARD_TYPE");
    
43.                         StructuredQueryResultset rCardType;
    
44. 
    
45.                         add_column<SQUInt>              ("CARD_PHYSICAL_TYPE", qCardType);
    
46.                         add_column<SQUInt>              ("CARD_LOGICAL_TYPE", qCardType);
    
47.                         add_column<SQString>            ("CARD_TYPE_NAME",160, qCardType);
    
48.                         add_column<SQUInt>              ("CARD_ATTRIBUTE", qCardType);
    
49. 
    
50.                         do_query(sql.str().c_str(), qCardType, rCardType, *(GetConnect()->datasource()));//,GetSid());
    
51. 
    
52.                         ApplicationMode.cardTypeNum = rCardType.size();
    
53.                         if(rCardType.size() > 0)
    
54.                         {
    
55.                                 for(StructuredQuery* row = rCardType.getFirstRow(); row; row = rCardType.getNextRow())
    
56.                                 {
    
57.                                         DataCardType CardType;
    
58.                                         CardType.physicalType = extract<uint32, SQUInt>(row->getFirstColumn());
    
59.                                         CardType.logicalType = extract<uint32, SQUInt>(row->getNextColumn());
    
60.                                         std::string name = (std::string&)extract<std::string, SQString>(row->getNextColumn());
    
61. 
    
62.                                         //中文名进行编码转换
    
63.                                         char strName[30];
    
64.                                         memset(strName,0,sizeof(strName));
    
65.                                         strcpy(strName,name.c_str());
    
66.                                         utf8togb2312Ykt(strName,30,CardType.cardTypeName,16);
    
67.                                         CardType.cardAttribute = extract<uint32, SQUInt>(row->getNextColumn());
    
68. 
    
69.                                         ApplicationMode.vDataCardType.push_back(CardType);
    
70.                                 }
    
71.                         }
    
72. 
    
73.                         m_DataApplicationMode.push_back(ApplicationMode);
    
74.                 }
    
75.         }
    
76. */
    
77.         rec.parameter_ver=(INT64)m_version;
    
78.         p=mk_where("parameter_ver",stmt);
    
79.         p=stpcpy(p," ORDER BY MODE_ID ASC");
    
80.         ret=DAU_select(&q_DAU,stmt,0);
    
81.         if(ret>0) {
    
82. //根据每一个ModeID,继续查询数据 -- 笛卡尔积
    
83.             DataCardType CardType;
    
84.                  DataApplicationMode ApplicationMode;
    
85. 
    
86.                 f_rec.parameter_ver=m_version;
    
87.                 mk_where("parameter_ver",stmt);
    
88.                 while(!DAU_next(&q_DAU)) {
    
89.                         ApplicationMode.modeID = (U32_t)rec.mode_id;
    
90.                         ret=DAU_prepare(&f_DAU,stmt);
    
91.                         if(ret==0) while(!DAU_next(&f_DAU)) {
    
92.                                 CardType.physicalType = (U32_t)f_rec.card_physical_type;
    
93.                                 CardType.logicalType = (U32_t)f_rec.card_logical_type;
    
94.                                 CardType.cardAttribute = (U32_t)f_rec.card_attribute;
    
95. //中文名进行编码转换
    
96.                                 utf8togb2312Ykt(f_rec.card_type_name,strlen(f_rec.card_type_name),
    
97.                                         CardType.cardTypeName,16);
    
98.                                 ApplicationMode.vDataCardType.push_back(CardType);
    
99.                         }
    
100.                 }
     
101.         }
     
102. 
     
103.         DAU_free(&q_DAU);
     
104.         DAU_free(&f_DAU);
     
105.         return true;
     
106. }
     
107.    

复制代码

它定义的数据结构与数据库有差异，否则我还可以减少不少语句。

boyatchinaunix

回复 66# yulihua49


   
Java 用的多了，没转换过来思维吧？即便有这样的函数，那底层呢？不也还是要转换为SQL？何来高效？

C就像手动档的汽车。
Java就像自动档的汽车，不要把手动档的按自动档的方法开。

boyatchinaunix

yulihua49 发表于 2013-11-26 12:04
这个值得讨论。
SQL面对的不是一个数据，是二维数据集，由行和列组成。
他的处理比较繁琐。我们希望能够 ...

在性能方面Hibernate是低下的，Hibernate解决的是业务需求频繁变化，数据库频繁改动的问题。
你的函数设计的也不太好，一个函数试图解决不同层面问题，结果if for 相互嵌套了多层，看到这些我就头晕。
如果你只是要跨各种数据库平台，推荐你用apr-util，apache下的开源项目，里面封装了各种数据库的调用接口。

yulihua49

boyatchinaunix 发表于 2013-11-26 13:16
回复 66# yulihua49

no 本人玩半辈子C了，JAVA，因团队需要，不得不接触一些，生的很。不过很受启发。