- 1
#define LEAP_YEAR_OR_NOT(year)( ( year % 4 ) ? ( 0 ) : ( 1 ) )
Нашли или выдавили из себя код, который нельзя назвать нормальным, на который без улыбки не взглянешь? Не торопитесь его удалять или рефакторить, — запостите его на говнокод.ру, посмеёмся вместе!
+1
#define LEAP_YEAR_OR_NOT(year)( ( year % 4 ) ? ( 0 ) : ( 1 ) )
Тот кто это писал, видимо рассуждал примерно так:
- В 2100 году это конечно забагует, но это будет уже не моя проблема.
−1
jsonObj_t *__jsonLoad(const char *_str_json, size_t _len_str_json, jsonErr_t *_error) {
jsonObj_t *obj_json = NULL;
jsonObj_t *obj_json_children = NULL; // Тут будет зиждется объект
jsonObj_t *obj_json_tmp = NULL; // Тут будет зиждется объект
size_t index_in_json_str = 0;
size_t len_key = 0; // Размер извлекаемого ключа
size_t len_value = 0; // Размер извлекаемого значения
size_t count_hooks = 0; // Счётчик скобок, чтобы игнорировать их при чтении объекта
uint8_t flag_found_separator = 0; // Флаг чтения ключа
uint8_t flag_found_start = 0; // Флаг начало JSON-объекта
// uint8_t flag_found_end = 0; // Флаг окончания JSON-объекта
uint8_t flag_read_key = 0; // Флаг чтения ключа
uint8_t flag_read_force_read = 0; // Флаг-костыль для ситуаций, когда число последнее в массиве
uint8_t flag_read_value = 0; // Флаг чтения значения
uint8_t flag_read_array = 0; // Флаг чтения и обработки массива
uint8_t flag_want_value = 0; // Флаг ожидания значения
// (выставляется после успешно прочитанного ключа)
jsonErr_t json_err = JSON_OK;
int res = 0;
jsonValueType_t type_expected_value = JSON_VALUE_NONE; // Ожидаемы тип считываемого значения
char chr_open = '\0';
char chr_close = '\0';
const char *ptr_key = NULL; // Указатель на начало извлекаемого ключа
const char *ptr_value = NULL; // Указатель на начало извлекаемого значения
if (_error != NULL)
{
*_error = JSON_OK;
}
for (index_in_json_str = 0; index_in_json_str < _len_str_json; ++index_in_json_str)
{
// Если начало JSON-объекта не найдено, то пропускать
if (flag_found_start == 0)
{
// Поиск начала JSON-объекта
if (_str_json[index_in_json_str] == '{')
{
flag_found_start = 1;
}
if (_str_json[index_in_json_str] == '[')
{
flag_found_start = 1;
flag_read_array = 1;
flag_want_value = 1;
flag_found_separator = 1; // Сразу после знака "[" ожидается значение
}
continue;
}
// Обработка ключа
if ((flag_read_key == 0) &&\
(flag_read_value == 0) &&\
(flag_want_value == 0) &&\
(flag_read_array == 0))
{
if (((_str_json[index_in_json_str] == '\"') || (_str_json[index_in_json_str] == '\'')))
{
chr_close = _str_json[index_in_json_str];
flag_read_key = 1; // Флаг начало чтения ключа
if ((index_in_json_str + 1) != _len_str_json)
{
ptr_value = (const char *)(_str_json + index_in_json_str + 1);
len_value = 1;
}
else
{
if (_error != NULL)
{
*_error = JSON_ERR_BAD_JSON;
}
jsonFree(obj_json);
return (NULL);
}
}
continue;
}
// Обработка значения
if ((flag_want_value == 1) && (flag_read_value == 0))
{
// Поиск разделителя ключа и значения
if (flag_found_separator == 0)
{
if ((_str_json[index_in_json_str] == ']') && (flag_read_array == 1))
{
// flag_found_end = 1;
Либа продакшеновая, эта функция около 470 строк кода, всё не вместилось... Нет, индусов у нас нет, как и ответственного за качество кода тоже) и да это ещё один парсер. Опирается ли он на спецификацию JSON? Нет конечно же, боже упаси, зачем? Зато она прекрасно понимает TRUE как true и FALSE как false, а ваши жалкие либы такого не могут
0
double func_atof(char *p){
double integer = 0.0, div = 1.0 , fract = 0.0 , sign = 1.0;
if( *p == 45 ){
sign = -1.0, *p++ ;
}
while ( isdigit(*p) ) {
integer = ( *p++ ) + (10.0 * integer) - 48.0 ;
}
if(*p == 46 ){
(*p++ ) ;
while ( isdigit(*p) ) {
fract = ( *p++ ) + (10.0 * fract) - 48.0 ;
div *= 10;
}
}
return (integer + fract / div ) * sign ;
}
Наше всё Гайвер и Сорокин
0
#include <stdio.h>
int main()
{
goto a;
h: printf("W"); goto i;
g: printf(" "); goto h;
m: printf("!"); goto n;
i: printf("o"); goto j;
n: printf("\n"); goto end;
b: printf("e"); goto c;
e: printf("o"); goto f;
j: printf("r"); goto k;
d: printf("l"); goto e;
f: printf(","); goto g;
a: printf("H"); goto b;
k: printf("l"); goto l;
l: printf("d"); goto m;
c: printf("l"); goto d;
end: ;
return 0;
}
+2
/* https://habr.com/ru/company/piter/blog/491996/
Пусть в Python такая штука и называется генератором, в языке C++ она
называлась бы корутиной. Пример взят с этого сайта: https://masnun.com/2015/11/13/python-generators-coroutines-native-coroutines-and-async-await.html
def generate_nums():
num = 0
while True:
yield num
num = num + 1
nums = generate_nums()
for x in nums:
print(x)
if x > 9:
*/
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <stdbool.h>
#define START 0
#define YIELD 1
typedef struct
{
uint8_t jmpto;
int num;
} coroutine_state;
int generate_nums(coroutine_state *state)
{
switch(state->jmpto)
{
case START: break;
case YIELD: goto yield;
}
while (true)
{
state->jmpto = YIELD; return state->num; yield: // какая питушня
state->num = state->num + 1;
}
}
int main(void)
{
int x;
coroutine_state st = {START, 0};
while(true)
{
x = generate_nums(&st);
printf("%d\n", x);
if (x > 9)
{
break;
}
}
return EXIT_SUCCESS;
}
Попробовал переписать эту ко-ко-корутину c питуха на Си - получилась какая-то херня нечитаемая. что еще раз доказывает, что корутины нахуй не нужны
К тому же в крестопарашном говне они требуют хип, а это нахуй не нужно на самом-то деле.
+4
static int parse_num(const char *s, size_t *out) {
if (s == NULL || *s == '\0')
return -1;
char *end = 0;
errno = 0;
uint64_t num = strtoull(s, &end, 0);
if (errno != 0)
return -1;
if (*end != '\0')
return -1;
if (num > SIZE_MAX)
return -1;
*out = (size_t)num;
return 0;
}
Какие же всё-таки удобные функции в стандартной няшколибе.
0
#include <stdlib.h>
void main()
{
a: ; malloc(1); goto a;
}
0
#include <stdio.h>
#include <csptr/smart_ptr.h>
#include <csptr/array.h>
void print_int(void *ptr, void *meta) {
(void) meta;
// ptr points to the current element
// meta points to the array metadata (global to the array), if any.
printf("%d\n", *(int*) ptr);
}
int main(void) {
// Destructors for array types are run on every element of the
// array before destruction.
smart int *ints = unique_ptr(int[5], {5, 4, 3, 2, 1}, print_int);
// ints == {5, 4, 3, 2, 1}
// Smart arrays are length-aware
for (size_t i = 0; i < array_length(ints); ++i) {
ints[i] = i + 1;
}
// ints == {1, 2, 3, 4, 5}
return 0;
}
Allocating a smart array and printing its contents before destruction.
C Smart Pointers
What this is
This project is an attempt to bring smart pointer constructs to the (GNU) C programming language.
Features: unique_ptr, shared_ptr macros, and smart type attribute
https://github.com/Snaipe/libcsptr
+6
#define add(x, y) &((void*)x)[y];
#define mul(x, y) (sizeof (char[x][y]))
из свитера
+3
#include <stdio.h>
#include <string.h>
#include "s_gets.h"
#define SIZE 30
void revers(char *);
int main(){
char str[SIZE];
s_gets(str, SIZE);
revers(str);
puts(str);
return 0;
}
void revers(char * str){
int size_ = strlen(str) - 1;
char tmp;
for(int i = size_; i >= 0; i--){
tmp = str[i];
str[i] = str[size_ - i];
str[size_ - i] = tmp;
}
}
https://ru.stackoverflow.com/questions/1173617/Изменения-строки-в-функции
> Собственно задание заключается в написании функции, которая заменяет содержимое указанной строки этой же строкой, но с обратным порядком следования символов. Почему строка не переворачивается?
Какой багор )))