Ниже приведён код пролога для  i386:



		pushl	%ebp                  

		movl	%esp, %ebp

		subl	$40, %esp

		movl	%gs:20, %eax

		movl	%eax, -4(%ebp)

          

Эпилог для i386 выглядит так:



		xorl	%gs:20, %eax

		jne	.L33

		...

	.L33:

		call	__stack_chk_fail // выводит сообщение и завершает работу приложения

static void __attribute__ ((constructor)) __guard_setup (void)

{

  unsigned char *p;

  int fd;



  if (__stack_chk_guard != 0)

    return;



  fd = open ("/dev/urandom", O_RDONLY);

  if (fd != -1)

    {

      ssize_t size = read (fd, &__stack_chk_guard,

                           sizeof (__stack_chk_guard));

      close (fd);

      if (size == sizeof(__stack_chk_guard) && __stack_chk_guard != 0)

        return;

    }



  /* If a random generator can't be used, the protector switches the guard

     to the "terminator canary".  */

  p = (unsigned char *) &__stack_chk_guard;

  p[sizeof(__stack_chk_guard)-1] = 255;

  p[sizeof(__stack_chk_guard)-2] = '\n';

  p[0] = 0;

}

сhar * __strcpy_chk (char *__restrict__ dest, const char *__restrict__ src,   size_t slen)

{

  size_t len = strlen (src);

  if (len >= slen)

    __chk_fail ();

  return memcpy (dest, src, len + 1);

}

char buf[5];



1)

memcpy (buf, foo, 5); 

strcpy (buf, "abcd");

2)

memcpy (buf, foo, n); 

strcpy (buf, bar);

3)

memcpy (buf, foo, 6); 

strcpy (buf, "abcde");

4)

char *p;

memcpy (p, q, n);

strcpy (p, q);

1)

     struct S 

     { 

        struct T 

       { 

           char buf[5]; 

           int x; 

       } t; 

       char buf[20]; 

     } var;

  

   strcpy (&var.t.buf[1], "abcdefg");

  char buf[20];

  int a;



  strcpy(buf, "hello%n");

  printf(buf, &a); 

Item->setOffset(-0.5*QPointF(pixmap.width(), pixmap.height()));

void PicItem::mousePressEvent(QGraphicsSceneMouseEvent *event)

{

  if ( event->button() == Qt::RightButton )

  {

    lastPos = event->pos();

    return;

  }

  

  QGraphicsPixmapItem::mousePressEvent(event);

}



void PicItem::mouseMoveEvent(QGraphicsSceneMouseEvent *event)

{

  if (event->buttons() & Qt::RightButton) 

  {

    qreal det = lastPos.x() * event->pos().y() - lastPos.y() * event->pos().x();

    qreal mod_a = sqrt(pow(lastPos.x(), 2) + pow(lastPos.y(), 2));

    qreal mod_b = sqrt(pow(event->pos().x(), 2) + pow(event->pos().y(), 2));

    qreal angle = asin(det / (mod_a * mod_b)) * 180 / M_PI;

    

    rotate(angle); 

    return;

  }

  

  QGraphicsPixmapItem::mouseMoveEvent(event);

}

void PicItem::wheelEvent(QGraphicsSceneWheelEvent * event)

{

  if ( hasFocus() ) 

  {    

    qreal fd_xy = (event->delta() > 0)?1.01:0.99;

    scale(fd_xy, fd_xy);

  }

}

Это все печально, но эта информация меня не удивила. Пора наверно привыкнуть, что любой "новый курс" у нас это так же и способ разворовать деньги, а работу поручают выполнять людям, которые в деле ничего не соображают. На Руси это было всегда...:(

#include "Etimer.h"



int main(int argc, char* argv[])

{

//создать переменную типа Etime_t

//эта структура данных 

//определена в файле Etimer.h.

	Etime_t mtime; 



//вызвать функцию EtimeInitialize 

//для инициализации переменной

	if ( !EtimeInitialize(&mtime) ) return -1;



//начало измерения

	if (Etime(&mtime))  

	{

		//измеряемый участок код ;)

		...

	

		//получаем время выполнения

		if (Etime(&mtime))  

		{

			printf("Выполнялось, сек = %16.13f\n", 

		                 EtimeDurationInSeconds(&mtime));

		}

	}



	return 0;

}

   Хоть эта модель работы мозга и сильно упрощённая, но опровергнуть её не просто:).

Я утверждаю, что система типов

     и семантика С++ чище, чем

                 его синтаксис

              Бьерн Страуструп

#include <iostream>



int main(int argc, char* argv[])

{

	int a = +-+-+-+-+10;

	int b = 5*-+-+a;

	

	std::cout << "a = " << a << std::endl;

	std::cout << "b = " << b << std::endl;

	

	

	{

		{

			{

				{

					10;

					std::cout << "Hello;)\n";

				}

			}

		}

	}

	

	((a > 10)?a:b) = 100;

	

	std::cout << "a = " << a << std::endl;

	std::cout << "b = " << b << std::endl;

	

	std::cout << ((2 < 5)?a=1, b=2, a+b: 0) << std::endl;

	(1 > 0)?0:throw 1;

	

	try

	{

		(1 < 0)?0:throw 1;

	}

	catch( ... )

	{

		std::cout << "Exception;)\n";

	}

	

	std::cout << "a = " << a << std::endl;

	std::cout << "b = " << b << std::endl;

	std::cout << !!!!!!!!!!!!1 << std::endl;

}

----------------------------------------------

	Результата работы программы

----------------------------------------------

a = 10

b = 50

Hello;)

a = 10

b = 100

3

Exception;)

a = 1

b = 2

1

------------------------------------------------

   Выражения с несколькими унарными знаками возможны согласно правилам:

	выражение-приведения =>

		унарное-выражение

	

	унарное-выражение =>

		унарный-оператор выражение-приведения



	унарный-оператор =>

		* & + - ! ~

   Несколько вложенных "составных инструкций" возможны по
правилам:

	инструкция =>

		составная-инструкция

		

	составная-инструкция =>

		{ последовательность-инструкций }

		

	последовательность-инструкций =>

		инструкция

   Приводить правила грамматики позволяющие строить с "условным выражением" такие конструкции я не буду, так как их много, если кому интересно смотрите, например в [1]. А следующее выражение допустимо, потому что оно выводима с помощью правил грамматики С++ и результат применения оператора к операнду lvalue является lvalue, если это приемлемо с точки зрения логики (lvalue - это выражение, ссылающееся на какую-то непрерывную область в памяти):


   ((a > 10)?a:b) = 100;

Например, на следующее выражение компилятор будет шибко ругаться, хотя оно и верно синтаксически, так как результат "логического ИЛИ" не есть lvalue:

   (a || b) = 1;

      Литература

1. Б. Страуструп. Язык программирования С++. Специальное издание.
2. Б. Страуструп. Дизайн и эволюция С++.