[Xenia 35]

Отчего бы не помечтать :)

Тогда я и свою мечто озвучу. Хочу... оператор сразу на две квадратные скобочки :), например, вот такой:

double operator [][]( int i, int j);

чтобы с матрицами стало удобно работать. Чтобы определив матрицу в виде объекта (создав ей кроме двумерного массива еще габариты, тип и прочее), можно было доставать из ее числа обычным способом, как Mat[j]. Для линейного объекта оператор [] решает все проблемы, а на двемерном случае это не работает, т.к. продукт оператора [] должен быть указателем, чтобы вторые скобочки сработали.

Можно конечно исхитриться, создав промеждуточный класс, указатель на который возвращает оператор [], а в том классе снова переопределить оператор [], но тогда управление перейдет в промежуточный класс, а не в исходный.

На худой случай можно было разрешить оператору [] иметь несколько аргументов, например:

double operator []( int i, int j, int k);

Кстати такое определение которые компиляторы кушают без ошибки. Однако тут подразумевается, что станут возможны выражения типа:

Mat[i, j, k]

что для C++ слишком непривычно.

[ReAl 0]

А уровень вложенности глупейшая задумка, криво реализуемая и потворствующая качественным ошибкам при правке кода.

+1

Замахаешься потом править уровни в случае чего.

Единственный приемлемый вариант - именованные блоки кода (break без имени - из ближайшего) - что-то в духе

    for(;; ) : mainloop {
        int i = 8;
        do : bitloop {
              while( aaa ) {
                  if( bbb )
                      break mainloop;
              }
              if( ccc )
                   break bitloop;                  
        } while(--i);
    }

[vmp 0]

Почему не делают в ЯВУ возврат из функций несколько переменных?

 

Вроде бы несложно было бы объявить функцию типо так:

(int,int,char) funcname(char);

 

Хмм... А чем вас возврат функцией структуры не устраивает?

typedef struct {
int a;
char b;
char c;
} T_S3;

T_S3 s3func(int i)
{
T_S3 s3;
s3.a = i+1;
s3.b = i+2;
s3.c = i+3;
return s3;
}

int test3(void)
{
int i;
i = s3func(1).a;
return s3func(i).b;
}

 

Листинг от IAR ARM 5.2

   \                                 In section .text, align 4, keep-with-next
  1325          T_S3 s3func(int i)
  1326          {
  \                     s3func:
  \   00000000   0200               MOVS     R2,R0
  \   00000002   82B0               SUB      SP,SP,#+8
  1327           T_S3 s3;
  1328           s3.a = i+1;
  \   00000004   481C               ADDS     R0,R1,#+1
  \   00000006   0090               STR      R0,[sP, #+0]
  1329           s3.b = i+2;
  \   00000008   881C               ADDS     R0,R1,#+2
  \   0000000A   6B46               MOV      R3,SP
  \   0000000C   1871               STRB     R0,[R3, #+4]
  1330           s3.c = i+3;
  \   0000000E   C91C               ADDS     R1,R1,#+3
  \   00000010   6846               MOV      R0,SP
  \   00000012   4171               STRB     R1,[R0, #+5]
  1331           return s3;
  \   00000014   03C8               LDM      R0!,{R0,R1}
  \   00000016   02B0               ADD      SP,SP,#+8
  \   00000018   03C2               STM      R2!,{R0,R1}
  \   0000001A   7047               BX       LR               ;; return
  1332          }
  1333          

  \                                 In section .text, align 4, keep-with-next
  1334          int test3(void)
  1335          {
  \                     test3:
  \   00000000   00B5               PUSH     {LR}
  \   00000002   83B0               SUB      SP,SP,#+12
  1336           int i;
  1337           i = s3func(1).a;
  \   00000004   0121               MOVS     R1,#+1
  \   00000006   6846               MOV      R0,SP
  \   00000008   ........           BL       s3func
  \   0000000C   0099               LDR      R1,[sP, #+0]
  1338           return s3func(i).b;
  \   0000000E   6846               MOV      R0,SP
  \   00000010   ........           BL       s3func
  \   00000014   6846               MOV      R0,SP
  \   00000016   0079               LDRB     R0,[R0, #+4]
  \   00000018   03B0               ADD      SP,SP,#+12
  \   0000001A   00BD               POP      {PC}             ;; return
  1339          }

[_Pasha 0]

Я бы хотел, чтоб в сях(да и паскале тоже) наконец-то исчез бардак в типе результата целочисленного умножения. Т.е. результат mul16x16 по умолчанию все же 32-битный должен быть, а 8*8 16-битный. Мы же все-таки в реальном мире находимся?

И чтобы препроцессор был рискованно рекурсивным

в командах break и continue (кстати, одинаковые для Си и Паскаля)

Нифига они не одинаковые изначально. В паскале это intrinsic procedures.

[sigmaN 0]

Сэр, по-моему у вас возникают дурные мысли по причине кризисного положения и недостатка реальной работы :)

 

Ну а по теме если: как и многие отписавшиеся, я не вижу ни надобности ни реального профита от задействования идей, предложенных Вами.

Но моё мнение так...мало что значит...программерская моя практика не так уж и велика....

 

Про структуру тоже хотел напомнить. Опередили :)

[_Pasha 0]

В принципе, было бы на 100% эффективным введение средств для задания идиоматических выражений (звучит смешно, вспоминая русский язык). Это, извините, не кривой плюсовый operator, а реальное средство, ускоряющее развитие оптимизаторов.

[AlexandrY 2]

LUA может возвращать переменные пачками.

http://www.lua.ru/doc/

 

LUA самый пожалуй удобный движок для портирования на микроконтроллеры. Занимает всего 100K памяти вместе с компилятором.

 

M-язык в среде MATLAB (тож можно exe-шники создавать на нем) возвращает переменные любыми способами.

 

Идея стара как мир.

 

А общее мнение таково: удобнее делать надо не языки, а средства разработки.

 

Совершенствовать броузинг кода и средства рефакторинга.

Языки же надо расширять стандартными общепринятыми либами и средствами генерации произвольных представлений.

Так чтобы был возможен автоматический ремапинг из одного языка в другой как это продвигает Microsoft в .NET технологии.

[GetSmart 0]

vmp, это то же самое как и передавать указатель на структуру в качестве параметра функции. Код будет 100% одинаковым. Переменнаяя/результат будет располагаться в стеке. Но т.к. современные компиляторы (сами) стараются располагать переменные в регистрах, то вместо этого устаревшего варианта возврата результата через стек пора бы уже вводить возврат результата (множественного) через регистры. Раньше было рано, а теперь в самый раз :)

[dxp 32]

vmp, это то же самое как и передавать указатель на структуру в качестве параметра функции. Код будет 100% одинаковым. Переменнаяя/результат будет располагаться в стеке.

Не факт. Структура по семантике языка возвращается по значению. Как на самом деле реализуется, зависит от платформы, тут надо смотреть доку на конкретную платформу. Например, у Blackfin/VDSP по поводу структур сказано следующее:

 

Return Values

 

•For functions returning aggregate values occupying fewer than or

equal to 32 bits, the result is returned in R0.

 

•For aggregate values occupying greater than 32 bits, and fewer than

or equal to 64 bits, the result is returned in register pair R0, R1.

 

•For functions returning aggregate values occupying more than 64

bits, the caller allocates the return value object on the stack and the

address of this object is passed to the callee as a hidden argument in

register P0.

 

И примеры приведены:

 

---------------------------------------------------------------------------------
Function Prototype    |  Parameters Passed as   |    Return Location
---------------------------------------------------------------------------------
struct s2 {           |          a in R0,       |        in R0 (s.t and s.u) 
char t;               |          b in R1,       |        and in R1 (s.v)     
char u;               |          c in R2        |
int v;                |                         |
}                     |                         |
                      |                         |
struct s2 test(int a, |                         |
int b, int c)         |                         |
---------------------------------------------------------------------------------
struct s3 {           |        a in R0,         |     in *P0 (based on value 
char t;               |        b in R1,         |     of P0 at the call, not 
char u;               |        c in R2          |     necessarily at the     
int v;                |                         |     return)                
int w;                |                         |
}                     |                         |
                      |                         |
struct s3 test(int a, |                         |
int b, int c)         |                         |
---------------------------------------------------------------------------------

 

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

Это всегда было и было отдано на откуп реализации. А если структура не лезет в регистры, то тут никакие новые правила языка не помогут - все равно будет передавать через память.

[_Pasha 0]

Переменнаяя/результат будет располагаться в стеке.

avr-gcc возвращает структуру, располагая ее в регистрах согласно calling conventions, либо на стеке, если она не вмещается.

[GetSmart 0]

Структура - структурой. А я предлагаю "симметрию" в описании параметров и результата функции. Чем не фича? ИМХО красивый концепт получается.

[GetSmart 0]

Ещё недоработку обнаружил. Volatile.

 

Этот квалификатор действует глобально на всю прогу и заставляет компилятор не оптимизировать переменную. Используется обычно тогда, когда в разных тредах, равно как и в программе+прерывании используется переменная. Но. Когда в программе юзается эта переменная, то она конечно может измениться и оптимизировать её не надо. Но когда в прерывании она юзается, то там было бы оптимальным снимать этот квалификатор. Но вроде бы это не предусмотрено. (?)

[vitan 2]

Почему не делают в ЯВУ возврат из функций несколько переменных?

 

Вроде бы несложно было бы объявить функцию типо так:

(int,int,char) funcname(char);

а потом аналогично использовать при вызове:

(a,b,c) = funcname('A');

причём даже в некоторых местах так:

(,,e) = funcname('A');

Возможно, немного не по теме, но, например, в AHDL (тоже язык высокого уровня) это возможно. Только синтаксис немного другой, но суть та же.

Так что - смотря о каких языках речь...

[_Pasha 0]

Но вроде бы это не предусмотрено. (?)

volatile int some;
int *someptr = &some;
*someptr += 2;

Ы?

[toweroff 0]

Ещё недоработку обнаружил. Volatile.

 

Этот квалификатор действует глобально на всю прогу и заставляет компилятор не оптимизировать переменную. Используется обычно тогда, когда в разных тредах, равно как и в программе+прерывании используется переменная. Но. Когда в программе юзается эта переменная, то она конечно может измениться и оптимизировать её не надо. Но когда в прерывании она юзается, то там было бы оптимальным снимать этот квалификатор. Но вроде бы это не предусмотрено. (?)

а если прерывание вложенное?