Random string generator c++

So why can't you use rand()? Because it may return a too-large value? Then pick a random value and if it's too large, (a) don't use it but pick another or (b) clip off the too large part using the % (modulus) operator:

my1stOwnRandomValue = rand() % 4;
my2ndOwnRandomValue = rand() % 4;
columnsAndRows=columns[my1stOwnRandomValue]+rows[my2ndOwnRandomValue];

This does not address "with no repeats", to do so you need more code. You may keep a list of 'used' values, or create a list of all possible combinations (after all there are only 16) and pick one at random from this list, then remove the picked combination from the list.

you can use time as the seed of random function this can aviod pseudo-random

srand((unsigned) time(NULL)); /*set seed must #include <time.h>*/
for(int i=0; i<10; i++) {
    for(int j=0; j<10; j++) {
      columnValue=rand() % 4;
      rowValue=rand() % 4;
      columnsAndRows=columns[columnValue]+row[rowValue];
    }
}

Here's a C++11 version:

#include <random>
#include <algorithm>
#include <iostream>
#include <cstddef>
#include <vector>

// helper to get the size (extent) of a raw array
template<class T, std::size_t N>
constexpr std::size_t get_extent(T&)
{  return std::extent<T>::value;  }

int main()
{
    std::string const chars[] = {"A","B","C"};
    std::string const digits[] = {"1","2","3","4"};

    // vector containing the resulting strings
    std::vector<std::string> result;

    // create the "ordered" sequence A1, A2, A3, A4, B1, ..
    for(auto const& eChar : chars)
        for(auto const& eDigit : digits)
            result.push_back( eChar+eDigit );

    // shuffle the sequence
    {
        // random device to seed the PRNG
        std::random_device rd;
        // create a MT19937 PRNG, seeded
        std::mt19937 g(rd());

        std::shuffle(begin(result), end(result), g);
    }

    // output result
    for(auto const& e : result) std::cout << e << ", ";
    std::cout << "\n";
}

A C++03 version:

#include <cstdlib>
#include <ctime>
#include <algorithm>
#include <iterator>
#include <iostream>
#include <cstddef>
#include <vector>

// helper to get the size (extent) of a raw array
template<class T, std::size_t N>
std::size_t get_extent(T (&)[N])
{  return N;  }

int main()
{
    std::string const chars[] = {"A","B","C"};
    std::string const digits[] = {"1","2","3","4"};

    // vector containing the resulting strings
    typedef std::vector<std::string> result_t;
    result_t result;

    // create the "ordered" sequence A1, A2, A3, A4, B1, ..
    for(std::string const* pChar = chars;
        pChar != chars + get_extent(chars);
        ++pChar)
        for(std::string const* pDigit = digits;
            pDigit != digits + get_extent(digits);
            ++pDigit)
            result.push_back( *pChar+*pDigit );

    // shuffle the sequence
    {
        std::srand( std::time(NULL) );
        std::random_shuffle(result.begin(), result.end());
    }

    // output result
    std::copy(result.begin(), result.end(),
              std::ostream_iterator<std::string>(std::cout, ", "));
    std::cout << "\n";
}

string strcat1 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
string strcat2 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
int stringl1 = strcat1.size() - 1;
int stringl2 = strcat1.size() - 1;
auto strfn1 = [&]() {return strcat2[rand() % stringl2];}; //will return a single char
auto strfn2 = [&]() {return strcat2[rand() % stringl2];};
while (true)
{
    this_thread::sleep_for(500ms);

    std::string str1(1, strfn1()); //fill 1 string/char space with arg2 here strfn1
    std::string str2(1, strfn2());
    std::string str3(1, strfn2());
    str1 += str2;
    str1 = str3 + str2 + str1 + str3; //as many adjacent string as you want
    cout << str1<<" ";
}

@Jongware

You can avoid generating a number larger than the provided range by using the minimum and the difference between the maximum and minimum range instead.

So rather than:

int x = rand() % max + min;

Use:

int diff = max - min;

int x = rand() % diff + min;