Trang 1 trên tổng số 2 12 Cuối cùngCuối cùng
Từ 1 tới 10 trên tổng số 12 kết quả

Đề tài: Mã nguồn C | một số code về C của tui !

  1. #1
    Ngày gia nhập
    09 2006
    Bài viết
    711

    Mặc định Mã nguồn C | một số code về C của tui !

    Tối nay rãnh rỗi, ngồi clean bớt mấy file rác, tìm thấy 1 file code C tui viết hồi xưa, lúc còn bắt đầu học C/C++. Tính xóa luôn nhưng nghỉ lại thấy uổng quá, thôi chịu khó post lên đây cho bà con, ai dùng được thì dùng, cám ơn tui một cái thì tốt, không thì cũng chả sao.
    File TQNLib của tui có gần 100 hàm, tui chỉ chọn post một ít hàm ở đầu, không đụng gì đến Windows hay MFC. Bà con chịu khó chỉnh sữa lại nếu không compile được trong compiler đang dùng của bà con:
    // TQNLib.cpp
    C Code:
    1. #include <stdio.h>
    2. #include <io.h>
    3. #include <direct.h>
    4. #include <gdiplus.h>
    5. #include "TQNLib.h"
    6.  
    7. static const int DayTable[2][13] = {
    8.     {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31},
    9.     {0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}
    10. };
    11.  
    12. static const LPSTR aszMonthName[] = {
    13.     "Illegal month",
    14.     "January", "February", "March", "April", "May", "June",
    15.     "July", "August", "September", "October", "November", "December"
    16. };
    17.  
    18. /*
    19.  * Count 1 bits in dw
    20.  */
    21. int BitCount(DWORD dw)
    22. {
    23.     int b;
    24.  
    25.     for (b = 0; dw != 0; dw >>= 1)
    26.         if (dw & 0x1)
    27.             b++;
    28.  
    29.     return b;
    30. }
    31.  
    32. int htoi(LPSTR lpszSrc)
    33. {
    34.     int ch, nRet = 0;
    35.  
    36.     if (!lpszSrc || !*lpszSrc)
    37.         return 0;
    38.  
    39.     while ((ch = *lpszSrc) != '\0' && isspace(ch)) {
    40.         lpszSrc++;
    41.     }
    42.  
    43.     if (lpszSrc[0] == '0' && tolower(lpszSrc[1]) == 'x')
    44.         lpszSrc += 2;
    45.  
    46.     while ((ch = *lpszSrc) != 0) {
    47.         if (isdigit(ch))
    48.             nRet = (nRet << 4) + (ch - '0');
    49.         else {
    50.             ch = tolower(ch);
    51.             if (ch >= 'a' && ch <= 'f')
    52.                 nRet = (nRet << 4) + (ch - 'a' + 10);
    53.             else
    54.                 return nRet;   // Fail, ch is not a hex character
    55.         }
    56.  
    57.         lpszSrc++;
    58.     }
    59.  
    60.     return nRet;
    61. }
    62.  
    63. int max3(int a, int b, int c)
    64. {
    65.     int m = (a > b) ? a : b;
    66.     return (m > c) ? m : c;
    67. }
    68.  
    69. int min3(int a, int b, int c)
    70. {
    71.     int m = (a < b) ? a : b;
    72.     return (m < c) ? m : c;
    73. }
    74.  
    75. /*
    76.  * Check valid nYear, nMonth, nDay
    77.  */
    78. static BOOL IsValidDate(int nYear, int nMonth, int nDay)
    79. {
    80.     return (nYear > 0 && nMonth > 0 && nMonth < 12 && nDay > 0
    81.             && nDay <= DayTable[IsLeapYear(nYear)][nMonth]);
    82. }
    83.  
    84. BOOL IsLeapYear(int nYear)
    85. {
    86.     return ((nYear % 4 == 0 && nYear % 100 != 0) || (nYear % 400 == 0));
    87. }
    88.  
    89. int DayOfYear(int nYear, int nMonth, int nDay)
    90. {
    91.     int  i;
    92.     BOOL bLeapYear = IsLeapYear(nYear);
    93.  
    94.     if (!IsValidDate(nYear, nMonth, nDay))
    95.         return 0;
    96.  
    97.     for (i = 1; i < nMonth; i++)
    98.         nDay += DayTable[bLeapYear][nMonth];
    99.  
    100.     return nDay;
    101. }
    102.  
    103. BOOL MonthDay(int nYear, int nYearDay, int *pnMonth, int *pnDay)
    104. {
    105.     int  i;
    106.     BOOL bLeapYear = IsLeapYear(nYear);
    107.  
    108.     if (nYear <= 0 || nYearDay <= 0 || nYearDay > (bLeapYear ? 366 : 365))
    109.         return FALSE;
    110.  
    111.     for (i = 1; nYearDay > DayTable[bLeapYear][i]; i++)
    112.         nYearDay -= DayTable[bLeapYear][i];
    113.  
    114.     *pnMonth = i;
    115.     *pnDay = nYearDay;
    116.  
    117.     return TRUE;
    118. }
    119.  
    120. LPSTR MonthName(int nMonth)
    121. {
    122.     return (nMonth < 1 || nMonth > 12) ? aszMonthName[0] : aszMonthName[nMonth];
    123. }
    124.  
    125. int ReadInput(LPSTR lpszBuff, int limit, InputMode mode)
    126. {
    127.     int index = 0;
    128.     int ch = getchar();
    129.  
    130.     while ((ch != '\n') && (ch != EOF) && (index < limit)) {
    131.         switch (mode) {
    132.             case imDigit:
    133.                 if (isdigit(ch)) {
    134.                     lpszBuff[index++] = ch;
    135.                 }
    136.                 break;
    137.  
    138.             case imAlpha:
    139.                 if (isalpha(ch)) {
    140.                     lpszBuff[index++] = ch;
    141.                 }
    142.                 break;
    143.  
    144.             case imString:
    145.                 if (isascii(ch)) {
    146.                     lpszBuff[index++] = ch;
    147.                 }
    148.                 break;
    149.  
    150.             default:
    151.                 /* this should not occur */
    152.                 break;
    153.         }
    154.  
    155.         ch = getchar();
    156.     }
    157.  
    158.     lpszBuff[index] = 0x00;  /* null terminate input */
    159.     return index;
    160. }
    161.  
    162. BOOL ReadInt(int *pIn)
    163. {
    164.     int c, sign;
    165.  
    166.     // Skip white space
    167.     while (isspace(c = getchar()) && c != '\n')
    168.         c = getchar();
    169.  
    170.     if (!isdigit(c) && c != '+' && c != '-')
    171.         return FALSE;
    172.  
    173.     sign = (c == '-') ? -1 : 1;
    174.  
    175.     if (c == '+' || c == '-') {
    176.         c = getchar();
    177.         if (!isdigit(c))
    178.             return FALSE;
    179.     }
    180.  
    181.     for (*pIn = 0; isdigit(c); c = getchar())
    182.         *pIn = 10 * *pIn + (c - '0');
    183.  
    184.     *pIn *= sign;
    185.  
    186.     return TRUE;
    187. }
    188.  
    189. int SafeStrLen(LPCSTR lpszSrc)
    190. {
    191.     return (lpszSrc != NULL) ? strlen(lpszSrc) : 0;
    192. }
    193.  
    194. LPSTR StrCapital(LPSTR lpszSrc)
    195. {
    196.     LPSTR lpsz = lpszSrc;
    197.     BOOL bFirst = TRUE;
    198.  
    199.     while (*lpsz != '\0') {
    200.         if (isalpha(*lpsz)) {
    201.             if (bFirst) {
    202.                 *lpsz = toupper(*lpsz);
    203.                 bFirst = FALSE;
    204.             }
    205.             else {
    206.                 *lpsz = tolower(*lpsz);
    207.             }
    208.         }
    209.         else {
    210.             bFirst = TRUE;
    211.         }
    212.  
    213.         lpsz++;
    214.     }
    215.  
    216.     return lpszSrc;
    217. }
    218.  
    219. LPSTR StrDelete(LPSTR lpszSrc, int nIndex, int nCount)
    220. {
    221.     int cbCopy;
    222.     int nLen = SafeStrLen(lpszSrc);
    223.  
    224.     if (nCount > 0 && nIndex < nLen && nIndex >= 0) {
    225.         if (nCount > nLen - nIndex)
    226.             nCount = nLen - nIndex;
    227.         cbCopy = nLen - (nIndex + nCount) + 1;
    228.         memcpy(lpszSrc + nIndex, lpszSrc + nIndex + nCount, cbCopy);
    229.     }
    230.  
    231.     return lpszSrc;
    232. }
    233.  
    234. /*
    235.  * Replace each string of one or more spaces by a single spaces
    236.  */
    237. LPSTR StrDelSpaces(LPSTR lpszSrc)
    238. {
    239.     int ch;
    240.     BOOL bSpace = FALSE;
    241.     LPSTR lpStore = lpszSrc;
    242.     LPSTR lpInc = lpszSrc;
    243.  
    244.     if (!lpszSrc || !*lpszSrc)
    245.         return lpszSrc;
    246.  
    247.     while ((ch = *lpInc) != '\0') {
    248.         if (!isspace(ch)) {
    249.             bSpace = FALSE;
    250.             *lpStore++ = ch;
    251.         }
    252.         else if (!bSpace) {
    253.             bSpace = TRUE;
    254.             if (lpInc[1] != '\0' || lpStore == lpszSrc)
    255.                 // last character of lpszSrc is not a space
    256.                 // or lpszSrc have only one character which is a space
    257.                 *lpStore++ = ch;
    258.         }
    259.  
    260.         lpInc++;
    261.     }
    262.  
    263.     *lpStore = '\0';
    264.  
    265.     return lpszSrc;
    266. }
    267.  
    268. LPSTR StrDelTrailBlanks(LPSTR lpszSrc)
    269. {
    270.     int nLen = 0;
    271.     BOOL bLFEnd = FALSE;
    272.     LPSTR lpBuf  = NULL;
    273.     LPSTR lpLine = NULL;
    274.  
    275.     int nSrcLen = SafeStrLen(lpszSrc);
    276.     if (nSrcLen == 0)
    277.         return lpszSrc;
    278.  
    279.     bLFEnd = lpszSrc[nSrcLen - 1] == '\n';
    280.     lpBuf = (LPSTR) malloc(nSrcLen);
    281.  
    282.     // StrGetLine will skip the first empty line,
    283.     if (*lpszSrc == '\n') {
    284.         lpBuf[nLen++] = '\n';
    285.     }
    286.  
    287.     lpLine = StrGetLine(lpszSrc);
    288.     while (lpLine != NULL) {
    289.         lpLine = StrRTrim(lpLine);
    290.         nSrcLen = strlen(lpLine);
    291.         memcpy(&lpBuf[nLen], lpLine, nSrcLen);
    292.         nLen += nSrcLen;
    293.         lpBuf[nLen++] = '\n';
    294.         lpLine = StrGetLine(NULL); // get next line
    295.     }
    296.  
    297.     memcpy(lpszSrc, lpBuf, nLen);
    298.  
    299.     lpszSrc[bLFEnd ? nLen : nLen - 1] = '\0';
    300.  
    301.     free(lpBuf);
    302.  
    303.     return lpszSrc;
    304. }
    305.  
    306. LPSTR StrGetLine(LPSTR lpszSrc)
    307. {
    308.     return strtok(lpszSrc, "\n");
    309. }
    310.  
    311. LPSTR StrGetWord(LPSTR lpszSrc)
    312. {
    313.     static const LPSTR szSeps = " \t\r\n";
    314.  
    315.     return strtok(lpszSrc, szSeps);
    316. }
    317.  
    318. LPSTR StrInvert(LPSTR lpszSrc)
    319. {
    320.     char ch;
    321.     LPSTR lpsz = lpszSrc;
    322.  
    323.     while ((ch = *lpsz) != '\0') {
    324.         *lpsz++ = isupper(ch) ? tolower(ch) : (islower(ch) ? toupper(ch) : ch);
    325.     }
    326.  
    327.     return lpszSrc;
    328. }
    329.  
    330. /*
    331.  * Remove a substring from a larger string. Search is case insensitive
    332.  * Return TRUE if any of pcszSub that have been removed from source string
    333.  */
    334. BOOL StrIRemove(LPSTR lpszSrc, LPCSTR lpcszSub)
    335. {
    336.     BOOL bRet = FALSE;
    337.     int nSubLen = SafeStrLen(lpcszSub);
    338.  
    339.     LPSTR lpszSubFound;
    340.     while ((lpszSubFound = StrIStr(lpszSrc, lpcszSub)) != NULL) {
    341.         strcpy(lpszSubFound, lpszSubFound + nSubLen);
    342.         lpszSrc = lpszSubFound;
    343.         bRet = TRUE;
    344.     }
    345.  
    346.     return bRet;
    347. }
    348.  
    349. BOOL StrIsEnd(LPSTR lpszSrc, LPSTR lpszEnd)
    350. {
    351.     return (StrRShare(lpszSrc, lpszEnd) == strlen(lpszEnd));
    352. }
    353.  
    354. BOOL StrIsStart(LPSTR lpszSrc, LPSTR lpszStart)
    355. {
    356.     return (StrLShare(lpszSrc, lpszStart) == strlen(lpszStart));
    357. }
    358.  
    359. /*
    360.  * Case insensitive test to see if a string is contained within another.
    361.  * It will fault if either of the strings are NULL.
    362.  * Return a pointer to the start of the search string
    363.  * If pszSource does not contain pcszSearch then returns NULL.
    364.  */
    365. LPSTR StrIStr(LPSTR lpszSrc, LPCSTR lpcszSearch)
    366. {
    367.     int nLen = SafeStrLen(lpcszSearch);
    368.  
    369.     while (*lpszSrc) {
    370.         if (!strnicmp(lpszSrc, lpcszSearch, nLen))
    371.             break;
    372.         lpszSrc++;
    373.     }
    374.  
    375.     if (!*lpszSrc)
    376.         return NULL;
    377.  
    378.     return lpszSrc;
    379. }
    380.  
    381. /*
    382.  * return the length of the common substring in 'lpsz1' and 'lpsz2' anchored
    383.  * at the beginning.  compare the characters with case sensitivity.
    384.  */
    385. size_t StrLShare(LPSTR lpsz1, LPSTR lpsz2)
    386. {
    387.     LPSTR p = lpsz1;
    388.  
    389.     while (*lpsz1 && *lpsz1 == *lpsz2) {
    390.         lpsz1++;
    391.         lpsz2++;
    392.     }
    393.  
    394.     return lpsz1 - p;
    395. }
    396.  
    397. /*
    398.  * Left trim the white space from a string. Will fault if NULL is passed.
    399.  */
    400. LPSTR StrLTrim(LPSTR lpszSrc)
    401. {
    402.     LPCSTR lpsz = lpszSrc;
    403.  
    404.     // find last non-space character
    405.     while (isspace(*lpsz))
    406.         lpsz++;
    407.  
    408.     if (lpsz != lpszSrc) {
    409.         // fix up data and length, must use memmove function
    410.         // because lpszSrc and lpsz are overlap
    411.         memmove(lpszSrc, lpsz, strlen(lpsz) + 1);
    412.     }
    413.  
    414.     return lpszSrc;
    415. }
    416.  
    417. /*
    418.  * Remove a substring from a source string. Search is case sensitive.
    419.  * Return TRUE if any of lpcszSub that have been removed from our source string
    420.  */
    421. BOOL StrRemove(LPSTR lpszSrc, LPCSTR lpcszSub)
    422. {
    423.     BOOL bRet = FALSE;
    424.     int nSubLen = SafeStrLen(lpcszSub);
    425.  
    426.     LPSTR lpszSubFound;
    427.     while ((lpszSubFound = strstr(lpszSrc, lpcszSub)) != NULL) {
    428.         strcpy(lpszSubFound, lpszSubFound + nSubLen);
    429.         lpszSrc = lpszSubFound;
    430.         bRet = TRUE;
    431.     }
    432.  
    433.     return bRet;
    434. }
    435.  
    436. /*
    437.  * Remove all occurances of a character in a string
    438.  */
    439. LPSTR StrRemoveChar(LPSTR lpszSrc, char ch)
    440. {
    441.     char c;
    442.  
    443.     LPSTR lpInc = lpszSrc;
    444.     LPSTR lpStore = lpszSrc;
    445.  
    446.     while ((c = *lpInc) != '\0') {
    447.         if (c != ch)
    448.             *lpStore++ = c;
    449.         lpInc++;
    450.     }
    451.  
    452.     *lpStore = '\0';
    453.  
    454.     return lpszSrc;
    455. }
    456.  
    457. /*
    458.  * Replace all occurances of a character in a string with a different character
    459.  */
    460. LPSTR StrReplace(LPSTR lpszSrc, char chOld, char chNew)
    461. {
    462.     char ch;
    463.     LPSTR lpsz = lpszSrc;
    464.  
    465.     // short-circuit the nop case
    466.     if (lpsz && chOld != chNew) {
    467.         while ((ch = *lpsz) != '\0') {
    468.             if (ch == chOld) {
    469.                 *lpsz = chNew;
    470.             }
    471.             lpsz++;
    472.         }
    473.     }
    474.  
    475.     return lpszSrc;
    476. }
    477.  
    478. LPSTR StrReverse(LPSTR lpSrc)
    479. {
    480.     LPSTR lpStart, lpEnd;
    481.  
    482.     int nLen = SafeStrLen(lpSrc);
    483.     if (nLen == 0)
    484.         return lpSrc;
    485.  
    486.     lpStart = lpSrc;
    487.     lpEnd = lpSrc + nLen - 1;
    488.  
    489.     while (lpStart < lpEnd) {
    490.         if (*lpStart == *lpEnd) {
    491.             --lpEnd;
    492.             ++lpStart;
    493.         }
    494.         else {
    495.             char ch = *lpEnd;
    496.             *lpEnd-- = *lpStart;
    497.             *lpStart++ = ch;
    498.         }
    499.     }
    500.  
    501.     return lpSrc;
    502. }
    503.  
    504. /*
    505.  * Return a pointer to the right n characters in the string. If the string is
    506.  * not long enough then it will return a pointer to the string passed
    507.  */
    508. LPCSTR StrRight(LPCSTR lpcszSrc, int nCount)
    509. {
    510.     if (nCount < 0)
    511.         nCount = 0;
    512.  
    513.     int nLen = SafeStrLen(lpcszSrc);
    514.     if (nCount >= nLen)
    515.         return lpcszSrc;
    516.     else
    517.         return lpcszSrc + nLen - nCount;
    518. }
    519.  
    520. /*
    521.  * return the length of the common substring in 's1' and 's2' anchored
    522.  * at the end.  compare the characters with case sensitivity.
    523.  */
    524. size_t StrRShare(LPSTR lpsz1, LPSTR lpsz2)
    525. {
    526.     size_t nLen1 = strlen(lpsz1);
    527.     size_t nLen2 = strlen(lpsz2);
    528.  
    529.     lpsz1 += nLen1;
    530.     lpsz2 += nLen2;
    531.  
    532.     // set nLen1 to shortest string length, use nLen2 as a counter
    533.     if (nLen2 < nLen1)
    534.         nLen1 = nLen2;
    535.  
    536.     nLen2 = 0;
    537.     while (nLen2 < nLen1 && *lpsz1-- == *lpsz2--) {
    538.         nLen2++;
    539.     }
    540.  
    541.     return nLen2;
    542. }
    543.  
    544. /*
    545.  * Strip off any trailing whitespace
    546.  */
    547. LPSTR StrRTrim(LPSTR lpszSrc)
    548. {
    549.     LPSTR lpsz = (lpszSrc != NULL) ? lpszSrc + strlen(lpszSrc) - 1 : NULL;
    550.     if (lpsz != NULL) {
    551.         for (; (lpsz >= lpszSrc) && isspace(*lpsz); lpsz--);
    552.         *++lpsz = '\0';
    553.     }
    554.  
    555.     return lpszSrc;
    556. }
    557.  
    558. /*
    559.  * Deletes all characters in lpszSrc that matches any character
    560.  * in lpszChars
    561.  */
    562. LPSTR StrSqueeze(LPSTR lpszSrc, LPSTR lpszChars)
    563. {
    564.     char c;
    565.     LPSTR lpsz;
    566.     LPSTR lpInc = lpszSrc;
    567.     LPSTR lpStore = lpszSrc;
    568.  
    569.     while ((c = *lpInc) != '\0') {
    570.         for (lpsz = lpszChars; *lpsz; lpsz++)
    571.             if (*lpsz == c)
    572.                 break;
    573.  
    574.         if (!*lpsz)
    575.             *lpStore++ = c; // not found c in lpszChars
    576.  
    577.         lpInc++;
    578.     }
    579.  
    580.     *lpStore = '\0';
    581.  
    582.     return lpszSrc;
    583. }
    584.  
    585. void StrStatistics(LPSTR lpszSrc, int *pcNonSpaces, int *pcSpaces,
    586.                    int *pcWords, int *pcLines)
    587. {
    588.     char ch;
    589.     BOOL bInWord = FALSE;
    590.  
    591.     *pcNonSpaces = *pcSpaces = *pcWords = *pcLines = 0;
    592.     if (!lpszSrc || !*lpszSrc)
    593.         return;
    594.  
    595.     // source string is not empty, so we can assume that we already have one line
    596.     *pcLines = 1;
    597.  
    598.     while ((ch = *lpszSrc) != '\0') {
    599.         if (ch == '\n' && *lpszSrc)
    600.             ++*pcLines;
    601.  
    602.         if (isspace(ch)) {
    603.             bInWord = FALSE;
    604.             ++*pcSpaces++;
    605.         }
    606.         else {
    607.             ++*pcNonSpaces;
    608.             if (!bInWord) {
    609.                 bInWord = TRUE;
    610.                 ++*pcWords;
    611.             }
    612.         }
    613.  
    614.         lpszSrc++;
    615.     }
    616. }
    617.  
    618. BOOL StrSymmetric(LPSTR lpszSrc)
    619. {
    620.     LPSTR pL, pR;
    621.  
    622.     int nLen = SafeStrLen(lpszSrc);
    623.     if (nLen == 0)
    624.         return FALSE;   // empty or null string
    625.  
    626.     pL = lpszSrc;
    627.     pR = lpszSrc + nLen - 1;
    628.  
    629.     while (pL < pR) {
    630.         if (*pL++ != *pR--)
    631.             return FALSE;
    632.     }
    633.  
    634.     return TRUE;
    635. }
    636. /*
    637.  * Find nFind in aInt with nCount elements and aInt was sorted ascending,
    638.  * aInt[0] <= aInt[1] <= ... <= aInt[nCount-1]
    639.  */
    640. int BinarySearch(int nFind, int aInt[], int nCount)
    641. {
    642.     int nL = 0;
    643.     int nU = nCount - 1;
    644.  
    645.     while (nL < nU) {
    646.         int nMid = (nL + nU) >> 1;
    647.         if (nFind < aInt[nMid])
    648.             nU = nMid - 1;
    649.         else if (nFind > aInt[nMid])
    650.             nL = nMid + 1;
    651.         else
    652.             return nMid;
    653.     }
    654.  
    655.     return -1;
    656. }
    657.  
    658. int BinarySearchEx(int nFind, int aInt[], int nCount)
    659. {
    660.     int nM, nL = -1, nU = nCount;
    661.  
    662.     while (nL + 1 != nU) {
    663.         nM = (nL + nU) >> 1;
    664.         if (aInt[nM] < nFind)
    665.             nL = nM;
    666.         else
    667.             nU = nM;
    668.     }
    669.  
    670.     int nPos = nL + 1;
    671.     if (nPos > nCount - 1 || aInt[nPos] != nFind)
    672.         nPos = -1;
    673.  
    674.     return nPos;
    675. }
    676.  
    677. /*
    678.  * Sort aInt into increasing order with Insertion Sort algorithm
    679.  */
    680. void InsertionSort(int aInt[], int nCount)
    681. {
    682.     for (int i = 1; i < nCount; i++) {
    683.         int j = i;
    684.         int tmp = aInt[j];
    685.         while (j > 0 && aInt[j - 1] > tmp) {
    686.             aInt[j] = aInt[j - 1];
    687.             j--;
    688.         }
    689.         aInt[j] = tmp;
    690.     }
    691. }
    692.  
    693. /*
    694.  * Sort aInt into increasing order
    695.  */
    696. void ShellSort(int aInt[], int nCount)
    697. {
    698.     register int i;
    699.     register int j;
    700.     register int gap;
    701.  
    702.     for (gap = nCount / 2; gap > 0; gap >>= 1) {
    703.         for (i = gap; i < nCount; i++) {
    704.             for (j = i - gap; j >= 0 && aInt[j] > aInt[j + gap]; j -= gap) {
    705.                 SWAP(int, aInt[j], aInt[j + gap]);
    706.             }
    707.         }
    708.     }
    709. }
    710.  
    711. /*
    712.  * Interchange two objects with sizeof(*pLeft) = sizeof(*pRight) = sizeObj
    713.  */
    714. inline void Exchange(void *pLeft, void *pRight, int sizeObj)
    715. {
    716.     int dwCount = sizeObj >> 2;  // DWORD count
    717.     int bCount = sizeObj & 3;    // Remainning byte count
    718.     register int i;
    719.  
    720.     for (i = 0; i < dwCount; i++) {
    721.         DWORD dw = *((LPDWORD) pLeft);
    722.         *((LPDWORD) pLeft)++ = *((LPDWORD) pRight);
    723.         *((LPDWORD) pRight)++ = dw;
    724.     }
    725.  
    726.     for (i = 0; i < bCount; i++) {
    727.         BYTE b = *((LPBYTE) pLeft);
    728.         *((LPBYTE) pLeft)++ = *((LPBYTE) pRight);
    729.         *((LPBYTE) pRight)++ = b;
    730.     }
    731. }
    732.  
    733. /*
    734.  * Sort the aInt array into increasing order
    735.  */
    736. void QuickSort(int aInt[], int nLeft, int nRight)
    737. {
    738.     register int i;
    739.     register int nM;
    740.     register int nT;
    741.  
    742.     /* Do nothing if array contains fewer than two elements */
    743.     if (nLeft >= nRight)
    744.         return;
    745.  
    746.     nM = nRight + 1;
    747.     nT = aInt[nLeft];
    748.  
    749.     for (i = nRight; i >= nLeft; i--)
    750.         if (aInt[i] >= nT)
    751.             Exchange(&aInt[--nM], &aInt[i]);
    752.  
    753.     // Resursion on two partition subset
    754.     QuickSort(aInt, nLeft, nM - 1);
    755.     QuickSort(aInt, nM + 1, nRight);
    756. }
    757.  
    758. /*
    759.  * Reverse the order of a array with elemCount elements
    760.  * and size of each element is elemSize bytes
    761.  */
    762. void Reverse(void *pSrc, int elemCount, int elemSize)
    763. {
    764.     if (elemCount <= 1 || elemSize <= 0)
    765.         return;
    766.  
    767.     void *pL = pSrc;
    768.     void *pH = (LPBYTE) pSrc + elemSize * (elemCount - 1);
    769.  
    770.     while (pL < pH) {
    771.         Exchange(pL, pH, elemSize);
    772.         (LPBYTE) pL += elemSize;
    773.         (LPBYTE) pH -= elemSize;
    774.     }
    775. }
    776.  
    777. /*
    778.  * Create a random int from nFrom to nTo - 1
    779.  */
    780. int RandRange(int nFrom, int nTo)
    781. {
    782.     if (nFrom > nTo)
    783.         return nTo + random(nFrom - nTo);
    784.     else
    785.         return nFrom + random(nTo - nFrom);
    786. }
    787.  
    788. /*
    789.  * Random an array of int which nCount elements
    790.  * and random period is 0 to nCount
    791.  */
    792. void RandArray(int *paInt, int nCount)
    793. {
    794.     int i;
    795.  
    796.     for (i = 0; i < nCount; i++)
    797.         paInt[i] = i;
    798.  
    799.     for (i = 0; i < nCount; i++)
    800.         Exchange(&paInt[i], &paInt[RandRange(i, nCount)]);
    801. }
    802.  
    803. /*
    804.  * Create an array of int which was sort ascending and contains
    805.  * M random int from 0..N-1. All random int not duplcates
    806.  */
    807. void RandSelect(int *paInt, int nCount, int nMax)
    808. {
    809.     int nSelect = nCount;
    810.     int nRemain = nMax;
    811.  
    812.     randomize();
    813.  
    814.     for (int i = 0, j = 0; i < nMax && j < nCount; i++) {
    815.         if ((double) rand() / RAND_MAX < (double) nSelect / nRemain) {
    816.             paInt[j++] = i;
    817.             nSelect--;
    818.         }
    819.         nRemain--;
    820.     }
    821. }
    // TQNLib.h
    C Code:
    1. #ifndef __TQNLIB_H_
    2. #define __TQNLIB_H_
    3.  
    4. #ifdef __cplusplus
    5. extern "C" {
    6. #endif
    7.  
    8. #define MAX_BUF_LEN     80  /* maximum length of buffer */
    9.  
    10. #define ABSDIFF(a, b)   ((a) > (b) ? (a) - (b) : (b) - (a))
    11.  
    12. #define SWAP(T, a, b) { \
    13.     T tmp = (a); \
    14.     (a) = (b); \
    15.     (b) = tmp; \
    16. }
    17.  
    18. #define TRUE            1
    19. #define FALSE           0
    20.  
    21. typedef enum {
    22.     imDigit,
    23.     imAlpha,
    24.     imString
    25. } InputMode;
    26.  
    27. int BitCount(DWORD dw);
    28.  
    29. int htoi(LPSTR lpszSrc);
    30. int max3(int, int, int);
    31. int min3(int, int, int);
    32.  
    33. int ReadInput(LPSTR lpszBuff, int limit, InputMode mode);
    34. BOOL ReadInt(int *pIn);
    35.  
    36. int SafeStrLen(LPCSTR lpszSrc);
    37.  
    38. size_t StrLShare(LPSTR lpsz1, LPSTR lpsz2);
    39. BOOL StrIsStart(LPSTR lpszSrc, LPSTR lpszStart);
    40.  
    41. size_t StrRShare(LPSTR lpsz1, LPSTR lpsz2);
    42. BOOL StrIsEnd(LPSTR lpszSrc, LPSTR lpszEnd);
    43.  
    44. LPSTR StrCapital(LPSTR lpszSrc);
    45. LPSTR StrDelete(LPSTR lpszSrc, int nIndex, int nCount);
    46. LPSTR StrDelSpaces(LPSTR lpszSrc);
    47. LPSTR StrDelTrailBlanks(LPSTR lpszSrc);
    48. LPSTR StrGetLine(LPSTR lpszSrc);
    49. LPSTR StrGetWord(LPSTR lpszSrc);
    50. LPSTR StrInvert(LPSTR lpszSrc);
    51. LPSTR StrIStr(LPSTR lpszSrc, LPCSTR lpcszSearch);
    52. LPSTR StrLTrim(LPSTR lpszSrc);
    53. LPSTR StrRTrim(LPSTR lpszSrc);
    54. BOOL StrRemove(LPSTR lpszSrc, LPCSTR lpcszSub);
    55. LPSTR StrRemoveChar(LPSTR lpszSrc, char ch);
    56. BOOL StrIRemove(LPSTR lpszSrc, LPCSTR lpcszSub);
    57. LPSTR StrReplace(LPSTR lpszSrc, char chOld, char chNew);
    58. LPSTR StrReverse(LPSTR lpszSrc);
    59. LPCSTR StrRight(LPCSTR lpszSrc, int nCount);
    60. LPSTR StrSqueeze(LPSTR lpszSrc, LPSTR lpszChars);
    61. void StrStatistics(LPSTR lpszSrc, int *pccNonSpace, int *pccSpace,
    62.                     int *pcWords, int *pcLines);
    63. BOOL StrSymmetric(LPSTR lpszSrc);
    64.  
    65. BOOL IsLeapYear(int nYear);
    66. int  DayOfYear(int nYear, int nMonth, int nDay);
    67. BOOL MonthDay(int nYear, int nYearDay, int *pnMonth, int *pnDay);
    68. LPSTR MonthName(int nMonth);
    69.  
    70. inline void Exchange(void *pLeft, void *pRight, int sizeObj = sizeof(int));
    71.  
    72. int  BinarySearch(int nFind, int aInt[], int nCount);
    73. int  BinarySearchEx(int nFind, int aInt[], int nCount);
    74.  
    75. void InsertionSort(int aInt[], int nCount);
    76. void ShellSort(int aInt[], int nCount);
    77. void QuickSort(int aInt[], int nLeft, int nRight);
    78.  
    79. void Reverse(void *pSrc, int elemCount, int elemSize);
    80. int  RandRange(int nFrom, int nTo);
    81. void RandArray(int *paInt, int nCount);
    82. void RandSelect(int *paInt, int nCount, int nMax);
    83.  
    84. #ifdef __cplusplus
    85. }
    86. #endif
    87.  
    88. #endif  // __TQNLIB_H_

    Có thể code có bug, nếu bà con dùng, chịu khó debug lại.
    Rì ga !
    Đã được chỉnh sửa lần cuối bởi TQN : 17-12-2008 lúc 12:30 PM.

  2. #2
    Ngày gia nhập
    07 2006
    Nơi ở
    Hanoi, Vietnam
    Bài viết
    2,750

    Cái này là rác hả? nhưng mà không phải dễ kiếm đâu nha. Hàng độc.

    Dreaminess vừa xem qua, thấy là nếu mổ sẻ ra có nhiều cái hay và bổ lắm.

    Very good! Thankyou for sharing!
    Email: admin[@]congdongcviet.com | CC to: info[@]congdongcviet.com
    Phone: 0972 89 7667 (Office: 04 6329 2380)
    Yahoo & Skype: dreaminess_world (Vui lòng chỉ rõ mục đích ngay khi liên hệ, cảm ơn!)

    Một người nào đó coi thường ý thức kỷ luật cũng có nghĩa là người đó đã coi thường tương lai số phận của chính bản thân người đó. Những người coi thường ý thức kỷ luật sẽ không bao giờ có được sự thành công trong sự nghiệp!

  3. #3
    Ngày gia nhập
    09 2006
    Nơi ở
    /usr/share/.hack@
    Bài viết
    1,433

    Làm theo bit high quality thật
    None!

  4. #4
    Ngày gia nhập
    09 2006
    Bài viết
    711

    Giờ nhìn code của mình mà tự hỏi, quái, sao hồi đó siêng quá vậy, và mình viết cái gì vậy. Hồi đó viết tiếng Anh giống cọp nhai đậu phộng quá, giờ thì giống cọp nhai bánh tráng.
    Rất nhiều code mà các bạn newbie hỏi đều có không ít thì nhiều trong cái mớ code bòng bong trên.

  5. #5
    Ngày gia nhập
    05 2007
    Bài viết
    3

    cám ơn anh về mấy code nay em đang rất cần để nghiên cứu thêm về C. có cái gì hay hay nữa các anh post lên nha!!!
    Thankyou very muck

    QUYẾT KHÔNG YÊU ĐỂ TIỀN MUA LAPTOP
    SỐNG MỘT MÌNH CHO GÁI THÈM CHƠI

  6. #6
    Ngày gia nhập
    12 2006
    Nơi ở
    US
    Bài viết
    1,917

    Mặc định Mã nguồn C | một số code về C của tui !

    anh TQN có thể viết thêm 1 chút ý tưởng về đoạn code trên được không ?
    File TQNLib của tui có gần 100 hàm, tui chỉ chọn post một ít hàm ở đầu, không đụng gì đến Windows hay MFC.
    Anh có thể giải thích về đoạn này được không ạ? Ý anh là include file đó vào hay sao nhỉ ? Cám ơn anh rất nhiều !

  7. #7
    Ngày gia nhập
    12 2006
    Nơi ở
    US
    Bài viết
    1,917

    - Hồi đầu đọc vào thấy mấy cái LPSTR... thực sự chẳng hiểu cái gì T_T, 1 năm sau đọc lại thì giờ đã hiểu ! Thanks anh rất nhiều ! Em nghĩ cái này chẳng có gì liên quan đến C++ cả anh nhỉ ! Nhưng pure C chắc chắn là faster !
    - Anh còn đoạn libs nào nữa thì cho mọi người luôn anh nhé !

  8. #8
    Ngày gia nhập
    07 2008
    Nơi ở
    /media/Anime
    Bài viết
    2,288

    Lâu quá mới thấy bác TQN vào 4rum. Hôm nay bác đến vứt vô 4rum một đống "rác" giá trị quá. Em phải "hốt" gấp để về ngâm cứu
    Càng yêu mèo thì mèo càng mập. Mèo càng mập ta lại càng yêu.

  9. #9
    Ngày gia nhập
    09 2008
    Bài viết
    28

    Cám ơn bác TQN nhiều lắm. Nghe danh đã lâu quả nhiên lời đồn đoán thật không sai. Em đọc ở đâu đó người ta nói nhiều khi "rác của người mà lại là kho báu của mình" cũng không chừng.

  10. #10
    Ngày gia nhập
    04 2010
    Bài viết
    21

    các bác nói giá trị, mà tôi chả thấy giá trị sao, nhờ các bạn chỉ ra dùm.

Các đề tài tương tự

  1. Tài liệu tối ưu hóa mã nguồn, tinh chỉnh mã nguồn (code Tuning)?
    Gửi bởi sunshine trong diễn đàn Nhập môn lập trình C/C++
    Trả lời: 1
    Bài viết cuối: 19-04-2013, 09:13 AM
  2. Mã nguồn C#, code bàn phím ảo viết bằng C#
    Gửi bởi troinau trong diễn đàn Dự án & Source code C#, ASP.NET
    Trả lời: 13
    Bài viết cuối: 06-11-2011, 12:07 AM
  3. Mã nguồn C++ | Code quản lý bán hàng
    Gửi bởi duc30121989 trong diễn đàn Thủ thuật, Tutorials và Mã nguồn C/C++/C++0x
    Trả lời: 2
    Bài viết cuối: 25-05-2009, 05:14 PM
  4. Mã nguồn C | Code Con Lật đật viết bằng C
    Gửi bởi lebatung trong diễn đàn Thủ thuật, Tutorials và Mã nguồn C/C++/C++0x
    Trả lời: 5
    Bài viết cuối: 22-11-2008, 06:25 PM
  5. Mã nguồn C | code in tam giác pascal
    Gửi bởi BuithiHa trong diễn đàn Thủ thuật, Tutorials và Mã nguồn C/C++/C++0x
    Trả lời: 1
    Bài viết cuối: 13-01-2008, 09:09 AM

Quyền hạn của bạn

  • Bạn không thể gửi đề tài mới
  • Bạn không thể gửi bài trả lời
  • Bạn không thể gửi các đính kèm
  • Bạn không thể chỉnh sửa bài viết của bạn