Selective password generator in C++ and Python

The first thing I'd suggest is to separate the user interactions and the code logic. A class for the actual password generation would allow you to only expose those parts that the user would need to access.

Also instead of several string concatenations, it seems to me that setting the maximum size of the string, copying the ones you want then resizing would probably be more efficient.

Here's my take on how it would look:

class PasswordChooser
{
    const string symbols = "`~!@#$%^&*()-=_+[]{}|;:\'\",<.>/\?";
    const string numbers = "1234567890";
    const string lowerCase = "abcdefghijklmnopqrstuvwxyz";
    const string upperCase = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    string pool;
    int totalLength = 0;
    bool poolCreated = false;

public:
    PasswordChooser( )
    {
    }

    string CreatePassword(int length,bool duplicates = true )
    {
        if ( !poolCreated )
        {
            return "Create pool first";
        }

        if ( length > pool.size() && !duplicates )
        {
            return "Length is too long.  Create a longer pool or change options";
        }
        string retVal;
        retVal.resize( length );
        for ( int i = 0; i < length; i++ )
        {
            int index = rand() % pool.size();
            retVal[i] = pool[index];
            if ( !duplicates )
            {
                pool.erase( pool.begin() + index);
            }
        }

        poolCreated = false;
        return retVal;
    }
    void CreatePool( bool hasSymbols = false , bool hasNumbers = false , bool hasLowerCase = false , bool hasUpperCase = false )
    {
        pool = string( symbols.length() + numbers.length() + lowerCase.length() + upperCase.length(),'\0' );
        totalLength = 0;
        if ( hasSymbols )
        {
            copy( symbols.begin() , symbols.end() , pool.begin() + totalLength );
            totalLength += symbols.length();
        }
        if ( hasNumbers )
        {
            copy( numbers.begin() , numbers.end() , pool.begin() + totalLength );
            totalLength += numbers.length();
        }
        if ( hasLowerCase )
        {
            copy( lowerCase.begin() , lowerCase.end() , pool.begin() + totalLength );
            totalLength += lowerCase.length();
        }
        if ( hasUpperCase )
        {
            copy( upperCase.begin() , upperCase.end() , pool.begin() + totalLength );
            totalLength += upperCase.length();
        }
        pool.resize( totalLength );
        if ( pool.size() == 0 )
        {
            poolCreated = false;
        }
        else
        {
            poolCreated = true;
            random_shuffle( pool.begin() , pool.end() );
        }
    }
};

I would make the logic in your Python main function slightly shorter by using what @Quuxplusone already suggested in his answer. But I would go further and make a get_password function that takes the requested length and the allowed characters as arguments. It uses str.join and random.choice. It also uses _ as name for an unused loop variable, as is customary in Python.

In addition, I implemented the argparse you would need, including the validation step that at least one charset should be used.

I made the charset a list, because extending lists is slightly faster than string addition, even though it probably won't matter in this small case.

Python also has a built-in string module that pre-defines a lot of commonly used character classes (and it has all of the ones you use).

I also renamed your variables according to Python's official style-guide, PEP8.

import argparse
import random
import string


def parse_args(args=None):
    parser = argparse.ArgumentParser()
    parser.add_argument("n", type=int, default=8, help="Length of password")
    parser.add_argument("--syms", action='store_true')
    parser.add_argument("--nums", action='store_true')
    parser.add_argument("--lower", action='store_true')
    parser.add_argument("--upper", action='store_true')

    args = parser.parse_args(args)
    if not (args.syms or args.nums or args.lower or args.upper):
        parser.error('No character options selected')

    return args


def get_password(n, allowed_chars):
    return "".join(random.choice(allowed_chars) for _ in range(n))


def main():
    # use argparse module to get arguments
    args = parse_args()

    allowed_chars = []
    if args.syms:
        allowed_chars.extend(string.punctuation)
    if args.nums:
        allowed_chars.extend(string.digits)
    if args.lower:
        allowed_chars.extend(string.ascii_lowercase)
    if args.upper:
        allowed_chars.extend(string.ascii_uppercase)

    # Use a password generating function
    print(get_password(args.n, allowed_chars))


if __name__ == "__main__":
    main()

Side note: I made the parse_args function accept an argument args, so I can easily test it. By default argparse tries to parse sys.argv, but if args is not None, it will take a list of strings. So you can test it with e.g. args = parse_args(["6", '--lower', '--upper']).