close

Вход

Забыли?

вход по аккаунту

?

Lab1 (part2)

код для вставкиСкачать
Міністерство науки и освіти України
Національний технічний університет України "Київський політехнічний інститут"
Лабораторна робота №1
(2 частина)
Виконав:
Студент групи: КВ-12
Корж Олександр Вячеславович
Перевірив:
Зорін Юрій Михайлович
____________________
Київ 2012
Завдання:
1.Написать функцию error_t argz_create_sep (const char *string, int sep, char **argz, size_t *argz_len). Функция преобразует null-terminated строку string в argz вектор разбивая строку на элементы всякий раз, когда встречается символ sep. Вектор argz есть null-terminated строка, в которой элементы разделены символом '\0'. 2. Написать функцию size_t argz_count (const char *argz, size_t arg_len), которая возвращает число элементов argz. Для предыдущего примера результатом будет 4.
3. Написать функцию error_t argz_add (char **argz, size_t *argz_len, const char *str), которая добавляет строку str в конец argz, модифицируя надлежащим образом argz и argz_len. 4. Написать функцию void argz_delete (char **argz, size_t *argz_len, char *entry), которая удаляет элемент entry из argz, модифицируя надлежащим образом argz и argz_len. 5. Написать функцию error_t argz_insert (char **argz, size_t *argz_len, char *before, const char *entry), которая вставляет строку entry перед элементом before, модифицируя надлежащим образом argz и argz_len. 6. Написать функцию char * argz_next (char *argz, size_t argz_len, const char *entry), которая обеспечивает возможность перемещения по argz. Она возвращает указатель на элемент argz, следующий за эементом entry или 0, если таковых нет. Если entry равен 0, возвращается укахзатель на первый элемент argz. Таким образом, обеспечивается одна из двух возможностей доступа к элементам argz
7. Написать функцию error_t argz_replace(char **argz, size_t *argz_len, const char *str, const char *with), которая замещает строку str элементом with, модифицируя надлежащим образом argz и argz_len. 8. Написать функцию void argz_print(const char *argz, size_t argz_len) печати argz.
Файл L2Header.h
/************************************************************************
*file: L2Header.h
*purpose: declarations for functions, definition of types
*written: 05/11/2012
*last modified: 06/11/2012
**************************************************************************/
#pragma once
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <malloc.h>
typedef enum {OK, ENOMEM} error_t;
void argz_print(const char *, size_t );
error_t argz_create_sep (const char *, int , char **, size_t *);
size_t argz_count (const char *, size_t);
error_t argz_add (char **, size_t *, const char *);
void argz_delete (char **, size_t *, char *);
error_t argz_insert (char **, size_t *, char *, const char *);
char * argz_next (char *, size_t , const char *);
error_t argz_replace(char **, size_t *, const char *, const char *);
Файл L2Functions.c
/************************************************************************
*file: L2Functions.c
*synopsis: The argz functions use malloc to allocate/grow argz vectors, and so any argz
* vector creating using these functions may be freed by using free; conversely, any argz
* function that may grow a string expects that string to have been allocated using malloc
* (those argz functions that only examine their arguments or modify them in place will work
* on any sort of memory). All argz functions that do memory allocation have a return type * of error_t, and return 0 for success, and ENOMEM if an allocation error occurs.
* These functions are declared in the include file "L2Hearder.h".
*related files: none
*written: 05/11/2012
*last modified: 08/11/2012
************************************************************************/
#include "L2Header.h"
/* The argz_create_sep function converts the null-terminated string string into an argz vector (returned in argz and argz len) by splitting it into elements at every occurrence of the character sep. */
error_t argz_create_sep (const char *string, int sep, char **argz, size_t *argz_len)
{
int i;
if (strlen(string)==NULL)
{
*argz_len=0;
return ENOMEM;
}
*argz=(char*)malloc(strlen(string));
strcpy(*argz,string);
for (i=0;i<=strlen(string);i++)
{
if ((*argz)[i]==sep)
(*argz)[i]=NULL;
}
*argz_len=strlen(string);
return OK;
}
/*Returns the number of elements in the argz vector.*/
size_t argz_count (const char *argz, size_t argz_len)
{
int i;
size_t count=0;
for (i=0;i<=argz_len;i++)
if (argz[i]==NULL)
count++;
return count;
}
/*The argz_add function adds the string str to the end of the argz vector *argz, and updates *argz and *argz_len accordingly. */
error_t argz_add (char **argz, size_t *argz_len, const char *str)
{
char *tmp=(char*)malloc(*argz_len+strlen(str));
int i;
if (argz_len==NULL)
return ENOMEM;
for (i=0;i<=*argz_len;i++)
tmp[i]=(*argz)[i];
for (i=*argz_len;i<=*argz_len+strlen(str);i++)
tmp[i]=str[i-*argz_len];
*argz=(char*)malloc(*argz_len+strlen(str));
*argz=tmp;
*argz_len=*argz_len+strlen(str);
return OK;
}
/*If entry points to the beginning of one of the elements in the argz vector *argz, the argz_delete function will remove this entry and reallocate *argz, modifying *argz and *argz_len accordingly. Note that as destructive argz functions usually reallocate their argz argument, pointers into argz vectors such as entry will then become invalid.*/
void argz_delete (char **argz, size_t *argz_len, char *entry)
{
int i=0,j,k,v,f=1;
while (i<*argz_len)
{
if ((*argz)[i]==entry[0])
{ k=i;
for (j=1;j<strlen(entry);j++)
{
k++;
if ((*argz)[k]!=entry[j])
{
f=0; break;
}
}
if ((k-i+1==strlen(entry))&&(f==1))
{ for (v=i;v<*argz_len-strlen(entry);v++)
(*argz)[v]=(*argz)[v+strlen(entry)];
(*argz)[v]=NULL;
*argz_len=*argz_len-strlen(entry);
}
}
i++; f=1;
}
}
/* The argz_insert function inserts the string entry into the argz vector *argz at a point just before the existing element pointed to by before, reallocating *argz and updating *argz and *argz_len. If before is 0, entry is added to the end instead (as if by argz_add). Since the first element is in fact the same as *argz, passing in *argz as the value of before will result in entry being inserted at the beginning.*/
error_t argz_insert (char **argz, size_t *argz_len, char *before, const char *entry)
{
int i=0,j,k,v,f=1,u=0;
char *tmp=(char*)malloc(*argz_len+strlen(entry));
if (*argz_len==NULL)
return ENOMEM;
while (i<*argz_len)
{
if ((*argz)[i]==before[0])
{ k=i;
for (j=1;j<strlen(before);j++)
{
k++;
if ((*argz)[k]!=before[j])
{
f=0; break;
}
}
if ((k-i+1==strlen(before))&&(f==1))
{ for (v=0;v<i;v++)
tmp[v]=(*argz)[v];
for (v=i;v<i+strlen(entry);v++)
{
tmp[v]=entry[u];
u++;
}
u=0;
for (v=i+strlen(entry);v<*argz_len+strlen(entry);v++)
{
tmp[v]=(*argz)[i+u];
u++;
}
tmp[v+1]=NULL;
*argz=(char*)malloc(*argz_len+strlen(entry));
*argz=tmp;
*argz_len=*argz_len+strlen(entry);
return OK;
}
}
i++; f=1;
}
}
/*The argz_next function provides a convenient way of iterating over the elements in the argz vector argz. It returns a pointer to the next element in argz after the element entry, or 0 if there are no elements following entry. If entry is 0, the first element of argz is returned.Note that the latter depends on argz having a value of 0 if it is empty (rather than a pointer to an empty block of memory); this invariant is maintained for argz vectors created by the functions here.*/
char * argz_next (char *argz, size_t argz_len, const char *entry)
{
int i=0,j,k,f=1;
char *p=(char*)malloc(1);
if (strlen(entry)==NULL)
{
*p=argz[0];
return p;
}
while (i<argz_len)
{
if (argz[i]==entry[0])
{ k=i;
for (j=1;j<strlen(entry);j++)
{
k++;
if (argz[k]!=entry[j])
{
f=0; break;
}
}
if ((k-i+1==strlen(entry))&&(f==1))
if (i+strlen(entry)>=argz_len)
*p=NULL;
else
*p=argz[i+strlen(entry)];
}
i++; f=1;
}
return p;
}
/* Replace the string str in argz with string with, reallocating argz as
necessary. */
error_t argz_replace(char **argz, size_t *argz_len, const char *str, const char *with)
{
int i=0,j,k,v,f=1,u=0;
char *tmp=(char*)malloc(*argz_len+strlen(with)-strlen(str));
if (*argz_len==NULL)
return ENOMEM;
while (i<*argz_len)
{
if ((*argz)[i]==str[0])
{ k=i;
for (j=1;j<strlen(str);j++)
{
k++;
if ((*argz)[k]!=str[j])
{
f=0; break;
}
}
if ((k-i+1==strlen(str))&&(f==1))
{ for (v=0;v<i;v++)
tmp[v]=(*argz)[v];
for (v=i;v<i+strlen(with);v++)
{
tmp[v]=with[u];
u++;
}
u=0;
for (v=i+strlen(with);v<*argz_len+strlen(with);v++)
{
tmp[v]=(*argz)[i+u];
u++;
}
tmp[v+1]=NULL;
*argz=(char*)malloc(*argz_len+strlen(with)-strlen(str));
*argz=tmp;
*argz_len=*argz_len+strlen(with)-strlen(str);
return OK;
}
}
i++; f=1;
}
} /*prints argz vector */
void argz_print(const char *argz, size_t argz_len)
{
int i;
printf("\n");
for(i=0;i<argz_len;i++)
if (argz[i]!=NULL)
printf("%c",argz[i]);
else
printf("\\0");
printf("\n");
}
Файл L2Test.c
/*********************************************************************
*file: L2Test.c
*synopsis: Test function by inputting the data
* These functions are declared in the include file "L2Header.h".
*related files: none
*written: 05/11/2012
*last modified: 08/11/2012
*********************************************************************/
#include "L2Header.h"
int main()
{
char *string="merz;ko;ghfd";
char *str="blabla";
char *entry="gh";
char *before="rz";
char *with="till";
int sep=';';
char *argz;
size_t argz_len;
//////////////// Function 1:
argz_create_sep (string,sep,&argz,&argz_len);
if (argz_create_sep (string,sep,&argz,&argz_len)==OK)
argz_print(argz,argz_len);
else
printf("Error. \n");
printf("%d\n",argz_len);
//////////////// Function 2:
printf("\n");
printf("Elements: %d\n",argz_count (argz,argz_len));
//////////////// Function 3:
if (argz_add (&argz, &argz_len, str)==OK)
argz_print(argz,argz_len);
else
printf("Error. \n");
printf("%d\n",argz_len);
//////////////// Function 4:
argz_delete (&argz, &argz_len, entry);
argz_print(argz,argz_len);
printf("%d\n",argz_len);
//////////////// Function 5:
if (argz_insert (&argz, &argz_len, before, entry)==OK)
argz_print(argz,argz_len);
else
printf("Error. \n");
printf("%d\n",argz_len);
//////////////// Function 6:
printf("\n");
printf("%c\n",*argz_next (argz,argz_len, entry));
//////////////// Function 7:
if (argz_replace(&argz, &argz_len, str, with)==OK)
argz_print(argz,argz_len);
else
{
printf("\n");
printf("Error. Argz = NULL or element str is not found.\n");
}
printf("%d\n",argz_len);
getchar();
}
Скріншот:
Документ
Категория
Рефераты
Просмотров
81
Размер файла
68 Кб
Теги
part, lab1
1/--страниц
Пожаловаться на содержимое документа