Problems with for loop c++

What you probably want is:

#include <iostream>
#include <vector>

int main() {
    std::vector<int> vec;
    int size = 0;

    std::cin >> size;

    for(int i = 0; i < size; i++){
        int number = 0;
        std::cin >> number;
        vec.push_back(number);
    }

    for(int i : vec){
        std::cout << i << " ";
    }
}

std::vector<int> is a class designed to provide an interface to resizable array. The push_back() function appends the vector with given argument.

The last loop, which is called a ranged-based for(), is used to print all elements of the vector. You can replace it with plain old for() loop with indexing, since std::vector supports operator [], but if ranged-based approach is sufficient, it should be preferred.

EDIT: I don't know JavaScript, but I assume (from your example) that variables declared inside loops are visible everywhere. This is not the case in C++. Variables' visibility is dependent on the scope they are declared in. If you want your list/array/vector/any other container to be visible to those two for() loops, you have to declare it outside them - like in my example above.

EDIT2: While you should almost always use std::vector for such tasks, one could argue that they want to disable resizing the container. In this case, we are left with simple dynamic allocation. We reach for <memory> library, since we shouldn't manage it ourselves:

#include <iostream>
#include <memory>

int main() {
    int size = 0;
    std::cin >> size;

    auto arr = std::make_unique<int[]>(size);

    for(int i = 0; i < size; i++){
        int number = 0;
        std::cin >> number;
        arr[i] = number;
    }

    for(int i = 0; i < size; i++){
        std::cout << arr[i] << " ";
    }
}

For auto, either read here or imagine that it's just a magic type that is (almost always) correct. It's like var in Python or JavaScript (but later on its type cannot be changed).

For std::unique_ptr<T[]>, either read here or imagine that it's just a dynamically allocated array that automatically delete[]s itself. If you did not learn about dynamic allocation yet, simply ignore what that means and wait until it's introduced.

Notice that we also got rid of the ranged-based for() loop. Unfortunately, it does not work with plain, dynamically allocated arrays.

Not all compilers support VLA so stick to the Standards; always specify a constant size for arrays. If you need some dynamically changed size then consider using another type of containers like: std::vector.

Also why you re-declared int w inside the for loop? It is local to for loop and changes to it won't affect the outer one.

You get a compile time error in the second loop that complains that w is not an array. To solve it make int w[] outer and on top of the two loops.

int n, k;
cin >> n >> k;
int w[n];

for(int i = 0; i < n; i++)
    cin >> w[i];

//some code here

for(int i = 0; i < n; i++)
    cout << w[i];

The alternative to VAL use std::vector:

std::vector<int> w;
int n, k;
std::cin >> n;

for(int i(0); i!= n; ++i){
    std::cin >> k;
    w.push_back(k);
}


for(auto i(0); i != w.length(); ++i)
    std::cout << w[i] << ", ";