Messing around with pass by reference, const and multidimensional vectors

I have a pretty big piece of code that I isolated in a header + implementation. This code is now a function

The whole code gets the data passed mostly by reference. The problem is that at some point, the function operates on a two dimensional vector of short int type, and this is what i came up with after several attemps:

function x ( vector<vector < short int > >& pwm_sequence );

Is this the right way to pass it?
Also, what possible flaws this passing might bring? If I want it as a const, where do i pass the const?

Thanks.

Uh..... So....... you need to have a vector that is filled with vectors that is filled with short ints?

Anyway, put the const before the data type. Hence:

Code:

function x ( const vector<vector < short int > >& pwm_sequence );

Since it's a reference, you can't change which variable the reference is referencing, hence you don't need to worry about the second const type (ie. it's not a pointer, so this is fine).

Actually, the const keyword (and other type modifiers, such as volatile and mutable) can go before or after the data type, just as data type keywords can go in any order. That is, these are all equivalent:

Code:

const long int *x;
long int const *x;
int long const *x;
long const int *x;

However, standard practice is to put const and other similar keywords first, followed by the data type.

Also note that const before an asterisk (*) or ampersand (&) in a pointer or a reference is not the same as a const afterwards. Before an asterisk, it makes a pointer-to-const (i.e., you can't modify the actual data that the pointer references); afterwards, and you get a constant pointer (i.e., you can't reassign the pointer to something else). The first form is most commonly used:

Code:

const int *x;

There's rarely a need to use a constant pointer:

Code:

int *const x;

>> Also, what possible flaws this passing might bring?

Passing it by reference is generally considered the proper way to do it. The reference should be const if you don't intend to modify the vector, which documents to the user of the function and to the compiler of that intention. Otherwise it should not be const. The only flaws are if you don't specify const but modify the data, or if you really need a copy of the data (which is rare), in which case you would not pass by reference.