Can anyone tell me why this code behaves this way?

cards is a linked list, you must allocated each node manually using malloc().

cards get_card(int num, string suit, cards *previous_card)
{
    cards card; // here is the memory problem
    card.num = num;
    card.suit = suit;
    card.next_card = previous_card;
    return card;
}

This code dynamically allocate a node of cards, the problem is that the node is freed the code return from the function.
Said otherwise, the code is just messing with the memory.
malloc - C++ Reference[^]
-----
Your code do not behave the way you expect, and you don't understand why !

There is an almost universal solution: Run your code on debugger step by step, inspect variables.
The debugger is here to show you what your code is doing and your task is to compare with what it should do.
There is no magic in the debugger, it don't know what your is supposed to do, it don't find bugs, it just help you to by showing you what is going on. When the code don't do what is expected, you are close to a bug.
To see what your code is doing: Just set a breakpoint and see your code performing, the debugger allow you to execute lines 1 by 1 and to inspect variables as it execute.
Debugger - Wikipedia, the free encyclopedia[^]

Mastering Debugging in Visual Studio 2010 - A Beginner's Guide[^]
Basic Debugging with Visual Studio 2010 - YouTube[^]
The debugger is here to only show you what your code is doing and your task is to compare with what it should do.

If that is meant as an exercise on linked list then you, as others already note, have to exercise more on linekd list.
On the other hand, if you really need to handle a deck of cards in a C++ program, then a linked list is possibly not the better choice. Try for instance

#include <vector>
#include <array>
#include <iostream>
using namespace std;

constexpr int VALUES = 13;
constexpr int SEEDS = 4;
constexpr int CARDS = VALUES * SEEDS;


class Card
{
  int v;

public:
  Card(int v):v(v){}
  int getValue() const { return (v % VALUES);}
  int getSeed() const { return (v / VALUES);}
  string getSeedDesc() const;
};

ostream & operator << ( ostream & os, const Card & card);


int main()
{
  vector <Card > card;

  for ( int n = 0; n < CARDS; ++n) card.emplace_back(Card(n));

  for (const auto & c : card) cout << c << endl;
}


ostream & operator << ( ostream & os, const Card & card)
{
  os << card.getValue() << " of " << card.getSeedDesc();
  return os;
}

string Card::getSeedDesc() const
{
  static array<string, SEEDS> desc = { "hearts", "diamonds", "clubs", "spades" };
  return desc[getSeed()];
}

Try this:

#include <iostream>
#include <string>
using namespace std;

struct cards
{
    int num;
    string suit;
    cards * next_card;
};

cards* get_card(int num, string suit, cards *previous_card)
{
    cards* card = new cards;;
    card->num = num;
    card->suit = suit;
    card->next_card = previous_card;
    return card;
}

int main()
{
    cards *temp_card = NULL;
    string suit;

    for (int i = 0; i<4; i++)
    {
        if (i == 0){suit = "hearts";}
        if (i == 1){suit = "diamonds";}
        if (i == 2){suit = "clubs";}
        if (i == 3){suit = "spades";}
        for (int j = 0; j<13; j++)
        {
            cards* sum_card = get_card(j+1, suit, temp_card);
//            cout << sum_card->num << " of " << sum_card->suit << ", next: " << sum_card->next_card << endl;
            temp_card = sum_card;
        }
    }
    while (temp_card != NULL)
    {
        cout <<temp_card->num <<" of ";
        cout <<temp_card->suit <<"\n";
//        cout <<temp_card->next_card <<"\n";
        temp_card = temp_card->next_card;
    }
//    cout <<"yis it work";
}

It could do with more tidying up but it fixes the problem of using the same address of a temporary structure for each link. It also tidies up the dereferencing of structure members, and correctly lists all the cards.