How can I declare and define multiple variables in one line using C++?

int column = 0, row = 0, index = 0;

With the following declaration, only the last variable (index) is set to 0:

int column, row, index = 0;

Instead, the following sets all variables to 0:

int column, row, index;
column = index = row = 0;

But personally, I find the following methods much more readable:

int column = 0, row = 0, index = 0;

int column = 0;
int row = 0;
int index = 0;

As @Josh said, the correct answer is:

int column = 0,
    row = 0,
    index = 0;

You'll need to watch out for the same thing with pointers. This:

int* a, b, c;

Is equivalent to:

int *a;
int b;
int c;

If you declare one variable/object per line not only does it solve this problem, but it makes the code clearer and prevents silly mistakes when declaring pointers.

To directly answer your question though, you have to initialize each variable to 0 explicitly. int a = 0, b = 0, c = 0;.

int column(0), row(0), index(0);

Note that this form will work with custom types too, especially when their constructors take more than one argument.

As of C++17, you can use Structured Bindings:

#include <iostream>
#include <tuple>

int main () 
{
    auto [hello, world] = std::make_tuple("Hello ", "world!");
    std::cout << hello << world << std::endl;
    return 0;
}

Demo

I wouldn't recommend this, but if you're really into it being one line and only writing 0 once, you can also do this:

int row, column, index = row = column = 0;

As others have mentioned, from C++17 onwards you can make use of structured bindings for multiple variable assignments.

Combining this with std::array and template argument deduction we can write a function that assigns a value to an arbitrary number of variables without repeating the type or value.

#include <iostream>
#include <array>

template <int N, typename T> auto assign(T value)
{
    std::array<T, N> out;
    out.fill(value);
    return out;
}

int main()
{
    auto [a, b, c] = assign<3>(1);

    for (const auto& v : {a, b, c})
    {
        std::cout << v << std::endl;
    }

    return 0;
}

Demo

Possible approaches:

• Initialize all local variables with zero.
• Have an array, memset or {0} the array.
• Make it global or static.
• Put them in struct, and memset or have a constructor that would initialize them to zero.

Pointers and references have similar syntax.

Some examples for newbies like me:

// correct.
int a = 1, b = 2, c = 3;
int *pa = &a, *pb = &b, *pc = &c;
int &ra = a, &rb = b, &rc = c;
a=4; b=5; c=6;
std::cout << ra << "," << rb << "," << rc << '\n'; // 4,5,6 (what we want)
std::cout << *pa << "," << *pb << "," << *pc << '\n'; // 4,5,6 (what we want)


// incorrect.
int a = 1, b = 2, c = 3;
// int* pa = &a, pb = &b, pc = &c; // error: invalid conversion from 'int*' to 'int'
int& ra = a, rb = b, rc = c;
a=4; b=5; c=6;
std::cout << ra << "," << rb << "," << rc << '\n'; // 4,2,3 (not 4,5,6)

For 0 as initial values, one line is enough. Otherwise, two more lines are needed.

#include <array>
#include <iostream>

int main(){
    std::cout << "Initial values are zeros." << std::endl;
    auto [a, b, c, d, e, f, g, h] = std::array<int, 8>{};
    std::cout << a << b << c << d << e << f << g << h << std::endl;

    std::cout << "Initial values are non-zeros." << std::endl;
    std::array<int, 8> arr;
    arr.fill(1);
    auto [i, j, k, l, m, n, o, p] = arr;
    std::cout << i << j << k << l << m << n << o << p << std::endl;
}

Output:

Initial values are zeros.
00000000
Initial values are non-zeros.
11111111