Как написать SWAP для любых типов данных на C

Передавай размер элемента третьим параметром.

Либо как сказали выше передавай размер, чтобы аллоцировать временный буфер, куда сложить a, потом в a b и в b временный буфер. Не забудь освободить.

Либо макросней, но это вообще по другому и твой преподаватель скорее всего спросит в чём отличие. :)

Не забудь учесть, что размер должен быть типа size_t, а не int. И не забудь про проверку результата malloc(). Желательно, чтобы функция возвращала значение, чтобы можно было вернуть код успеха/ошибки. Ну поставь assert’ы, что входные указатели не нулевые и не равны друг другу.

Какие еще аллокации в swap?

void swap (void* a, void* b, size_t n) {
    size_t buf_size = 64; // можно больше, можно меньше
    char buf[64];
    size_t m = n % buf_size;
    n /= buf_size;
    for (size_t i = 0; i < n; i++) {
        memcpy (buf, a, buf_size);
        memcpy (a, b, buf_size);
        memcpy (b, buf, buf_size);
    }
    memcpy (buf, a, m);
    memcpy (a, b, m);
    memcpy (b, buf, m);
}

Проверки сам допишешь.

Как написать SWAP для любых типов данных на C

Для базовых типов данных?

Ну допустим есть такая структура:

struct Person {
  char *name; /* Dynamically allocated */
  struct {
    uint64_t length_meters;
    uint64_t diameter_meters;
  } Penis;
};

Какие ты видишь проблемы при memcpy() такой структуры?

Еще раз, какие могут быть аллокации в swap?

Желательно, чтобы функция возвращала значение, чтобы можно было вернуть код успеха/ошибки.

Как может провалиться swap?

Никаких проблем нет.

Еще раз, какие могут быть аллокации в swap?

Кстати да, в C99 и выше можно без кучи обойтись

void f(size_t sz) {
  char buf[sz];
}

Как может провалиться swap?

Легко: передали нулевой указатель, а мы как давай его разыменовывать. Тут вам не кресты со ссылками, там да:

void swap(Penis &lhs, Penis &rhs) noexcept;

Никаких проблем нет.

Вот и я о чём, поэтому и спросил анонимуса, почему он интересуется базовые типы, или нет.

Кстати да, в C99 и выше можно без кучи обойтись

Еще раз, какая куча может быть в swap’е? VLA хотя и можно задействовать, но нет никакого смысла.

Легко: передали нулевой указатель, а мы как давай его разыменовывать.

А если острым себе в глаз ткнуть, что будет?

VLA хотя и можно задействовать, но нет никакого смысла.

У нас sizeof(struct Penis) == 1024, ты ему char buf[64]. И что мы получили? Получили мы кусочек пениса, вместо полноценного штруя.

Понятно. Когда человек не видит очевидной ошибки в коде, ему только и остается писать проверки.

Неверно, подумайте еще раз.

Кстати, тут надо сами указатели инкрементировать, раз копируем кусочками. А для этого надо кастить указатели к char*.

А вот это правильный ответ. Поздравляю.

Чтобы менять местами пенисы покусочно нужен очень умелый хирург…

Вы сделали мой день!

Ну я не виноват, что у ТС такие лабы.

vvediteima вот что преподавателю ответь

Чтобы менять местами пенисы покусочно нужен очень умелый хирург…

Да благословит тебя Святой Делириум!

В современном С есть возможность определить тип данных и вызвать в зависимости от типа нужную функцию.

Вот тебе прикол с дженериками:

#define FUNC(arg) _Generic(arg, uint16_t: funcu, int32_t: funci)(arg)

void funcu(uint16_t arg){
    printf("uint16_t: %u\n", arg);
}

void funci(int32_t arg){
    printf("int32_t: %d\n", arg);
}

int main(){
    uint16_t u = 32;
    int32_t i = -50333;
    FUNC(u);
    FUNC(i);
    return 0;
}

А еще можно просто макрос написать (в надежде, что не попадется разнотипных аргументов):

#define swap(a,b) {register typeof(a) t = a; a = b; b = t;}

P.S. Bass, ты с головой дружишь? Как можно анонимуса призвать в закрытый для постинга анонимусом тред?

// Eddy_Em

Да и вообще, меня всегда можно «скастовать», написав на мыло или отправив сообщение в пейсбуке, ЖЖшке, фконтактиге или ватсапе.

vvediteima вот что преподавателю ответь

Для того, чтобы поменять местами пенисы покусочно нужно знать их размер ...

vvediteima вот что преподавателю ответь

Для того, чтобы поменять местами пенисы покусочно нужно знать их размер, иначе не ... /"Гусарам молчать!"/ не получится

Очевидно - нужен третий параметр, либо указатель на функцию, либо указатель на тип, либо размер. Но размер - это провал, т.к. структура может содержать указатели.

Очевидно - нужен третий параметр, либо указатель на функцию, либо указатель на тип, либо размер. Но размер - это провал, т.к. структура может содержать указатели.

Подолью масла в огонь.
А если структура к примеру vector содержит?

В C нет векторов никаких!

А вот если там список, то с этим даже хваленые кресты не справятся! Все равно придется писать отдельную функцию для этого случая (но конкретно для свопа проще указатели местами поменять)!

В C нет векторов никаких!

Вы правы

Я таким макросом пользуюсь:

#define swap(Type, a, b) do         \
{                                   \
    Type *const _swpA = (a);        \
    Type *const _swpB = (b);        \
    Type const _swp = *_swpA;       \
    *_swpA = *_swpB, *_swpB = _swp; \
} while (0)

Какие ты видишь проблемы при memcpy() такой структуры?

Ну ты и слабенький, никаких проблем там не будет, указатели можно смело обменивать. Или ты собрался обменивать местами данные на которые указывает name🤣🤣🤣. Я же говорю, реально слабенький.

VLA хотя и можно задействовать

VLA же на стеке. Обязательно потом какой-нибудь долбодятел сунет sz=0xFFFFFFFFF и улетит в stack overflow.

Вот, например, без вообще без вызовов (а также проверок и оптимизаций)

#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>

#define SWAP_BYTE(X,Y)   \
    do {                 \
        (X) = (X) ^ (Y); \
        (Y) = (X) ^ (Y); \
        (X) = (X) ^ (Y); \
    } while(0);

static inline void
swap_buffer (void* A, void* B, size_t sz) {
    uint8_t* B1 = (uint8_t*) A;
    uint8_t* B2 = (uint8_t*) B;
    
    for (uint32_t i = 0; i < sz; i++)
        SWAP_BYTE(B1[i],B2[i]);
}

int
main (int argc, char* argv[]) {
    int T1 = 12345, T2 = -456789;
    fprintf (stdout, "T1: %d\tT2: %d\n", T1, T2);
    swap_buffer (&T1,&T2, sizeof(int));
    fprintf (stdout, "T1: %d\tT2: %d\n", T1, T2);
    return 0;
}

(X) = (X) ^ (Y); \

(Y) = (X) ^ (Y); \

(X) = (X) ^ (Y); \

Это называется «Я у мамы какир».

Как написать SWAP для любых типов данных на C (комментарий)

Это называется «стандартная херня, которую любой школьник знает».

Вносите царя

Это называется «стандартная херня, которую любой школьник знает, но в код тянут только мамкины какеры".

Полностью Согласен.

Это называется «стандартная херня, которую любой школьник знает».

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

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

Ну я ж отметил, что и не претендовал на оптимальное решение.

Решается обоими двумя первыми вариантами. Двойная диспетчеризация будет реализована по разному, но быть собой от этого не перестанет.

А если надо засвопить структуру вида:

struct node_st {
int handle;
size_t data_size;
void* data;
};

struct root_st {

int handle;
struct node_st* node;

};

?

Всё норм. int поменяется и указатель поменяется.

Это же swap, а не copy.

Угу, а если в узле добавится ссылка на родителя?

Ок. Я не прав.

Здесь просто один буфер побайтово меняется с другим буфером. Без затей. Ссылки в списках оно ест-но не поменяет.

Очевидно, что никак.

Тогда вроде как не решается задача из ОП поста?

Очевидно, что никак.

Ну раз местный эксперт по C сказал, что никак, то пора расходиться по домам.