суббота, 20 марта 2010 г.

Выделение памяти в stack

Обычно при динамическом выделении памяти используется heap. Однако такое выделение возможно и в stack’е. Для этого можно использовать набор функций _malloca и _freea, которые задекларированы в заголовочном файле memory.h

Рассмотрим функцию _malloc:

void *_malloca( size_t size ); – size – размер выделяемой области памяти в байтах. Функция возвращает указатель на выделенную память. Если происходит ошибка, то возвращается нулевой указатель (NULL).

Для освобождения памяти используется функция _freea:

void _freea( void *memblock ); – memblock – указатель на участок памяти, который нам необходимо освободить.

Рассмотрим пример использования данных функций:

#include <malloc.h>
#include <string.h>
int main(int argc, char* argv[])
{
    char *p=(char *)_malloca(200);
    if(p){
        char *str="Hello, world!";
        strcpy_s(p,200,str);
        printf("%s", p);
        _freea(p);
    }else
        printf("Cannot allocate memory\n");
    return 0;
}

суббота, 12 декабря 2009 г.

Python...

Изменим чуть-чуть сообщения блога. Посмотрим взаимодействие с python.

В данном примере разберем обращение из python к библиотекам языка C.
Например, создадим скрипт для доступа к printf из библиотеки libc.dylib (MacOS). Для организации данного доступа необходимо воспользоваться модулем python ctypes, который позволяет обращаться к функциям из c-библиотек.


from ctypes import *


Загрузим библиотеку через CDLL:


libc=CDLL("libc.dylib")


Вызовем функцию printf и закончим первый пример:


message="Hello, world"
i=libc.printf("First program: %s\n",message)


суббота, 20 июня 2009 г.

Информация по изменениям...

Всю информацию по изменениям в блогах по программированию на различных языках, о добавлении новых презентаций, о начале новых курсов можно узнать через twitter: AlexeiBo

четверг, 7 мая 2009 г.

Презентации

Хотел бы напомнить, что презентации по темам, связанным с языками С и С++ и не только, доступны на ресурсе:
SlideShare

Продолжение работы со списками

Рассмотрим работу с одно связанным списком, но предположим, что в списке каждая предыдущая структура хранит указатель на последующую. В этом случае, как я упоминал ранее в предыдущем посте, надо хранить указатель на первую структуру в списке. Если мы потеряем первую структуру, то потеряем и элементы списка. А почему? Она - одно связанная, указатель - с предыдущей на последующую, а, следовательно, мы можем двигаться только от первой к последней структуре в списке. Иначе не получится! ;)
А теперь код. Он похож на предыдущей, только вместо pLast и prev используем pFirst и next:


typedef struct S2{int a; int b; S2* next;} S2_t;

// одно связанный список

S2_t *p2=0, *pLast2=0, *pFirst=0;

//построение списка

for(int i=0;i<10;++i)
{
p2=(S2_t *)malloc(sizeof(S2_t));
memset(p2,0,sizeof(S2_t));
p2->a=i;
p2->b=i+10;
if(pLast2)
pLast2->next=p2;
else
pFirst=p2;
pLast2=p2;
}

//работа со списком

p2=pFirst;
while(p2){
printf("a: %d b: %d\n", p2->a,p2->b);
p2=p2->next;
}

//Удаляем четные элементы

p2=pFirst;
S2_t* p22=pFirst;
while(p2){
if(!(p2->a&1)){
if(p2==pFirst){
p22=p2->next;
pFirst=p22;
free(p2);
p2=p22;
}else{
p22->next=p2->next;
free(p2);
p2=p22->next;
}
}else{
p22=p2;
p2=p2->next;
}
}

printf("After removing:\n");
p2=pFirst;
while(p2){
printf("a: %d b: %d\n", p2->a,p2->b);
p2=p2->next;
}

//удаление списка

p2=pFirst;
while(p2){
pFirst=p2->next;
free(p2);
p2=pFirst;
}

Работа с динамическими списками

Посмотрим как работают динамические списки. Из чего они состоят? Из структур, в каждой из которой есть указатель на предыдущую либо последующую. Это верно для одно связанных списков. У дву связанных есть указатель на предыдущую и последующую одновременно.
Структура может выглядеть так:

typedef struct S1{int a; int b; S1* prev;} S1_t;

- имеет указатель на предыдущую

typedef struct S2{int a; int b; S2* next;} S2_t;

- имеет указатель на последующую

Построим для первой структуры список из 10 элементов:


printf("first:\n");
// односвязанный список
S1_t *p1=0, *pLast=0;
//построение списка
for(int i=0;i<10;++i)
{
p1=(S1_t *)malloc(sizeof(S1_t));
memset(p1,0,sizeof(S1_t));
p1->a=i;
p1->b=i+10;
if(pLast)
p1->prev=pLast;
pLast=p1;
}


Выведем список на экран:

 
p1=pLast;
while(p1){
printf("a: %d b: %d\n", p1->a,p1->b);
p1=p1->prev;
}


Удалим из списка структуры, которые содержат первое нулевое поле либо четное:

 
p1=pLast;
S1_t* p11=pLast;
while(p1){
if(!(p1->a&1)){
if(p1==pLast){
p11=p1->prev;
pLast=p11;
free(p1);
p1=p11;
}else{
p11->prev=p1->prev;
free(p1);
p1=p11->prev;
}
}else{
p11=p1;
p1=p1->prev;
}
}


После работы надо освободить память:


p1=pLast;
while(p1){
pLast=p1->prev;
free(p1);
p1=pLast;
}


В начале работы со списком я всегда устанавливаю указатель p, с которым работаю, в начало списка.
При работе с одно связанным списком главное хранить указатель на последний элемент списка, если в списке указатели в структурах указывают с последующей на предыдущую структуры.
И надо хранить указатель на первую структуру в списке, если предыдущая структура хранит указатель на последующую.
В следующем посте я приведу пример для такой структуры.

понедельник, 17 ноября 2008 г.

__gnu_cxx и __verbose_terminate_handler

Отвлечемся от std. Рассмотрим пространство имен __gnu_cxx, в котором объявлен __verbose_terminate_handler, позволяющий получить больше информации о возникающей исключительной ситуации. Замечу, что это все тот же заголовочный файл exception.
Рассмотрим следующий код:

int main (int argc, char * const argv[]) {
std::cout << "Hello, World!\n";
std::set_terminate(__gnu_cxx::__verbose_terminate_handler);
int k=120;
if(k>100)
throw std::exception();
else
throw k;
for(int i=k;i<1000;++i)
std::cout<<".";
return 0;
}

На выходе получаем следующее:

[Session started at 2008-11-17 23:42:53 +0300.]
Hello, World!
terminate called after throwing an instance of 'std::exception'
what(): St9exception

Как видно из примера, при возникновении исключительной ситуации выводится дополнительная информация о ней, что в некоторых случаях может быть полезным.