20190723_C的三个小实现

1. 有一个字符串开头或结尾含有n个空格（“    abcdefgdddd   ”），欲去掉前后的空格，返回一个新的字符串。
a) 要求1：请自己定义一个接口（函数），并实现功能；
b) 要求2：编写测试用例。
c) 函数： int trimSpace(char * inbuf, char * outbuf);

 .    有一个字符串开头或结尾含有n个空格（“    abcdefgdddd   ”），欲去掉前后的空格，返回一个新的字符串。
 a)    要求1：请自己定义一个接口（函数），并实现功能；
 b)    要求2：编写测试用例。
 c)    函数： int trimSpace(char * inbuf, char * outbuf);

 //API函数
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>

 #pragma warning(disable:4996)

 /*
     子业务函数api
 */

 int trimSpace(char* string_input_trim, char* string_output_trim)
 {
     //判断 业务函数 形参是否为 Null
     int returnTrim = ;

     if (string_input_trim == NULL || string_output_trim == NULL)
     {
         returnTrim = -;

         printf("trimSpace error: %d in (string_input_trim == NULL || string_output_trim == NULL)\n", returnTrim);

         return    returnTrim;
     }

     //在被调用函数中，定义辅助指针 * 变量，把形参接过来，不要轻易改变被调用函数中的形参值
     char* s_i_t = string_input_trim;
     char* s_o_t = string_output_trim;

     char* space_cut = ' ';
     int i = ;
     int j = ;

     //裁剪函数，核心算法
     //while (s_i_t = strstr(s_i_t, space_cut))
     //{

     //}
     for (i = ; i < strlen(s_i_t); i++)
     {
         if (*(s_i_t + i) != ' ')
         {
             *(s_o_t + j) = *(s_i_t +i);
             j++;
         }
         else
         {
             continue;
         }

     }

     //这个功能是可以实现的
     //for(i = 0; i < strlen(s_i_t); i++)
     //{
     //    printf("%c\n", *(s_i_t + i));
     //}

     *(s_o_t + j) = '\0';

     printf("%s\n", s_i_t);
     printf("%s\n", s_o_t);

     //返回值
     return returnTrim;
 }

 int main_hw01()
 {

     int returnMain = ;

     char* string_input_main = "     abcdefgdddd      ";
     char* string_output_main = (char*)malloc();

     //这个功能是可以实现的
     /*for (int i = 0; i < strlen(string_input_main); i++)
     {
         printf("%c", *(string_input_main + i));
     }*/

     //returnMain = clientAPI(string_input_main, string_output_main);
     returnMain = trimSpace(string_input_main, string_output_main);

     if (returnMain != )
     {
         printf("clientAPI error: %d\n", returnMain);
     }
     else
     {
         printf("string after trimming: %s\n", string_output_main);
     }

     system("pause");
     return returnMain;
 }

2. 有一个字符串 “1a2b3d4z”:
要求写一个函数实现如下功能
a) 把偶数位字符挑出来，组成一个字符串1。
b) 把奇数位字符挑出来，组成一个字符串2。
c) 把字符串1和字符串2，通过函数参数，传给main，并打印。
d) 函数：getStr1Str2(char *source, char* buf1, char *buf2);

 //API函数
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>

 #pragma warning(disable:4996)

 /*
     API 函数区
 */
 //int clientAPI(char * main, char * buf)
 int getStr1Str2(char* get_string, char* odd_string, char* even_string)
 {
     /*
         形参判断区，定义返回变量
     */
     int getReturnValue = ;

     if (get_string == NULL || odd_string == NULL || even_string == NULL)
     {
         getReturnValue = -;

         printf("trimSpace error: %d in (string_input_trim == NULL || \
             string_output_trim == NULL)\n", getReturnValue);

         return    getReturnValue;
     }

     /*
         辅助指针区
         在被调用函数中，定义辅助指针 * 变量，
         把形参接过来，不要轻易改变被调用函数中的形参值
     */
     char* gs = get_string;
     char* os = odd_string;
     char* es = even_string;

     /*
         算法区
     */
     int i;
     int e_j = ;
     int o_j = ;

     //for (i = 0; i < strlen(gs); i = i + 2)
     //{
     //    *(es + e_j) = *(gs + i);
     //    e_j++;
     //}
     for (i = ; i < strlen(gs); i++)
     {
         if (i %  == )
         {
             *(es + e_j) = *(gs + i);
             e_j++;
         }
         else
         {
             *(os + o_j) = *(gs + i);
             o_j++;
         }
     }

     *(es + e_j) = '\0';
     *(os + o_j) = '\0';

     /*
         返回区
     */

     return getReturnValue;
 }

 /*
     主函数区
 */
 int main2019072301()
 {
     /*
         参数区
     */
     int returnMain = ;

     char* string_main = "1a2b3d4z";
     //int string_length = sizeof(string_main);

     //char* string_odd[(const int)string_length];
     //char* string_even[(const int)string_length];
     char* string_odd = malloc();
     char* string_even = malloc();

     /*
         函数调用区
     */
     returnMain = getStr1Str2(string_main, string_odd, string_even);

     /*
         返回区
     */
     if (returnMain != )
     {
         printf("clientAPI error: %d\n", returnMain);
     }
     else
     {
         printf("even string: %s\n", string_even);
         printf("odd string: %s\n", string_odd);
     }

     system("pause");
     return returnMain;
 }

3. 键值对 (“key = value”) 字符串，在开发中经常使用；
a) 要求1：请自己定义一个接口，实现根据key获取valude。
b) 要求2：编写测试用例
c) 要求3：键值对中间可能有n多空格，请去除空格。
d) 注意：键值对字符串格式可能如下
i. “key1 = valude1”
ii. “key2 =      valude2”
iii. “key3    = valude3”
iv. “key4         valude4”
v. “key5    =    “
vi. “key6    =  ”
vii. “key7    =     “
e) 函数：int getKeyByValude(char* keyvaluebuf, char* keybuf, char* valuebuf, int* valuebuflen);
f) 例子：“ORACLE_name = itcast” “ORACLE_name” itcast “oracle_pwd=123456” “oracle_pwd” 123456 “oracle_pwd=  123456” “oracle_pwd” 123456
g) 函数例子  int main(){ getKeyByValude(“key1=  valude1  “, “key1”, buf, &len)}

 //API函数
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>

 #pragma warning(disable:4996)

 /*
     API 函数区，专注算法
 */
 //int clientAPI(char * main, char * buf)
 int getKeyValue(char* getString, char* getKey,char* getValue, int* valueLength)
 {
     /*
         形参判断区，定义返回变量
     */
     int returnGetKeyValue = ;
     if (getString == NULL || getKey == NULL || \
         getValue == NULL || valueLength == NULL)
     {
         printf("error in (getString == NULL || getKey == NULL || \
         getValue == NULL || valueLength == NULL) = %d", returnGetKeyValue);
         returnGetKeyValue = -;
     }

     /*
         辅助指针区
         在被调用函数中，定义辅助指针 * 变量，
         把形参接过来，不要轻易改变被调用函数中的形参值
     */
     char* gs = getString;
     char* gk = getKey;
     char* gv = getValue;
     int* vl = valueLength; //strlen(gs)

     /*
         算法区
     */
     int i = ;
     int j = ;
     while (*gs != '\0')
     {
         printf("*gs = %c\n", *gs);
         if (*gs == '=')
         {
             gs = gs + ;
             break;
         }
         else if (*gs == ' ')
         {
             gs = gs + ;
             continue;
         }
         else
         {
             *(gk + i) = *gs;
             //gk++;
             i++;
             gs++;
         }
     }

     while (*gs != '\0')
     {
         printf("*gs = %c\n", *gs);
         if (*gs == ' ')
         {
             gs = gs + ;
             continue;
         }
         else
         {
             *(gv + j) = *gs;
             //gv++;
             j++;
             gs++;
         }
     }

     *(gk + i) = '\0';
     *(gv + j) = '\0';

     /*
         返回区
     */
     printf("key = %s\n", gk);
     printf("value = %s\n", gv);

     /*
     key = key5
     value = value12345
     */

     return returnGetKeyValue;
 }

 /*
     API 函数区，专注输出,多参函数的调用，TBC
 */

 int globalPrint(int sInfo, ...)
 {
     int returnGlobalPrintValue = ;

     return returnGlobalPrintValue;
 }

 /*
     主函数区
 */
 int main()
 {
     /*
         参数区
     */
     int returnMain = ;

     char* string_main = "key5   =      value12345   ";
     char* string_key = malloc();
     char* string_value = malloc();
     int value_length = ;
     value_length = strlen(string_main);

     /*
         函数调用区
     */
     returnMain = getKeyValue(string_main, string_key, string_value, &value_length);

     /*
         返回区
     */
     if(returnMain != )
     {
         printf("clientAPI error: %d\n", returnMain);
     }
     else
     {

     }

     system("pause");
     return returnMain;
 }

 int mainxxxx()
 {
     char* gs = "key5   =      value12345   ";
     char* gt = "key";
     printf("strlen = %d\n", strlen(gs));
     printf("sizeof = %d\n", sizeof(gs));

     printf("%s\n", *(gt + strlen(gt)));
     printf("%c\n", *(gt + strlen(gt)));
     /*

     */

     for (int i = ; i < strlen(gt); i++)
     {
         printf("%c\n", *(gt + i));
     }
     /*
         trlen = 27
         sizeof = 4
         (null)
         k
         e
         y
     */
     for (int i = ; i < strlen(gt) + ; i++)
     {
         printf("%c\n", *(gt + i));
     }
     /*
         k
         e
         y

     */

     /*for (int i = 0; i < strlen(gt) + 1; i++)
     {
         printf("%s\n", *(gt + i));
     }*/
     /*
     引发了异常: 读取访问权限冲突。
         **it** 是 0x6B。

     */

     /*printf("%s\n", *(gt + 1));*/

     //char* ptr = "abc";
     //printf(ptr);
     //printf("\n%c\n",*(ptr + 1));
     //printf("\n%s\n",*(ptr + 1));    //引发了异常: 读取访问权限冲突。**it** 是 0x62。
     char* gg = (char*)malloc();
     //while (*gt != NULL)
     //{
     //    *gg = *gt;
     //    gg++;
     //    gt++;
     //}

     for (int i = ; i < strlen(gt) + ; i++)
     {
         *(gg + i) = *(gt + i);
     }
     //*gg++ = '\0';
     printf("%s\n", gg);

     system("pause");
     return ;
 }

 int mainxxxc()
 {
     char* string = "key = 3";
     for (int i = ; i < strlen(string); i++)
     {
         printf("%c\n", *(string + i));
     }
     /*
     k
     e
     y

     =

     3
     */

     for (int i = ; i < strlen(string) + ; i++)
     {
         printf("%c\n", *(string + i));
     }
     /*
     k
     e
     y

     =

     3

     */
     char* k = (char*)malloc();
     char* v = (char*)malloc();
     for (int i = ; i < strlen(string) + ; i++)
     {
         if (*(string + i) == '=')
         {
             printf("found '='\n");
         }
         else
         {
             printf("not found '='\n");
         }
     }

     /*
     not found '='
     not found '='
     not found '='
     not found '='
     found '='
     not found '='
     not found '='
     not found '=' --> '\0'
     */

     //char* string = "key = 3";
     int j = ;
     int i = ;
     //for (i = 0; i < strlen(string); i++)
     //{
     //    *(k + i) = *(string + i);
     //    if (*(string + i) == '=')
     //    {
     //        //for (; i < strlen(string); i++)
     //        //{
     //        //    *(v + j) = *(string + i + 1);
     //        //}
     //        for (j = 0; j < strlen(string); j++)
     //        {
     //            *(v + j) = *(string + i + 1);
     //            i++;
     //        }
     //    }

     //}

     //for key
     for (i = ; i < strlen(string); i++)
     {
         *(k + i) = *(string + i);
         printf("%c\n", *(k + i));
         //key is key
         /*
         k
         e
         y

         =
         */

         if (*(string + i) == '=')
         {
             printf("x  %c\n", *(string + i));
             printf("y  %c\n", *(string + i +));
             string = string + i + ;
             printf("%c\n", *string);
             /*
             x  =
             y

             */
             break;
         }
     }

     for (j = ; j < strlen(string); j++)
     {
         printf("z    %c\n", *string);
         *(v + j) = *(string + j);
     }

     /*
     key is ke
     value is
     */

     *(k + i) = '\0';
     *(v + j) = '\0';

     printf("key is %s\n", k);
     printf("value is %s\n", v);

     system("pause");

     return ;
 }