#include "cryptopp/modes.h"
        #include "cryptopp/aes.h"
        using namespace CryptoPP;
        // ...
        byte key[AES::DEFAULT_KEYLENGTH], iv[AES::BLOCKSIZE];
        // initialize key and iv here
        CFB_Mode<AES >::Encryption cfbEncryption(key, AES::DEFAULT_KEYLENGTH, iv);

        AES::Encryption aesEncryption(key, AES::DEFAULT_KEYLENGTH);
        CFB_Mode_ExternalCipher::Encryption cfbEncryption(aesEncryption, iv);

        byte plaintext[100], ciphertext[100];
        // put data into plaintext here
        // encrypt
        cfbEncryption.ProcessData(ciphertext, plaintext, 100);
        // now decrypt
        CFB_Mode<AES >::Decryption cfbDecryption(key, 16, iv);
        cfbDecryption.ProcessData(plaintext, ciphertext, 100);

        std::string ciphertext;
        StreamTransformationFilter cfbEncryptor(cfbEncryption, new StringSink(ciphertext));
        cfbEncryptor.Put(plaintext, 100);
        // input more plaintext here if needed
        cfbEncryptor.MessageEnd();
        return ciphertext;

  byte key[Twofish::DEFAULT_KEYLENGTH], iv[Twofish::BLOCKSIZE];
  string plainText;

  // ... populate key, iv, plainText here

  string cipher;
  StringSink* sink = new StringSink(cipher);
  Base64Encoder* base64_enc = new Base64Encoder(sink);
  CBC_Mode<Twofish>::Encryptor twofish(key, Twofish::DEFAULT_KEYLENGTH, iv);
  StreamTransformationFilter* twofish_enc = new StreamTransformationFilter(twofish, base64_enc);
  StringSource source(plainText, true, twofish_enc);

#include <iostream>
#include <iomanip>

#include "modes.h"
#include "aes.h"
#include "filters.h"

int main(int argc, char* argv[]) {

    //
    // Key and IV setup
    //
    byte key[ CryptoPP::AES::DEFAULT_KEYLENGTH ], iv[ CryptoPP::AES::BLOCKSIZE ];
    memset( key, 0x00, CryptoPP::AES::DEFAULT_KEYLENGTH );
    memset( iv, 0x00, CryptoPP::AES::BLOCKSIZE );

    //
    // String and Sink setup
    //
    std::string plaintext = "Now is the time for all good men to come to the aide...";
    std::string ciphertext;
    std::string decryptedtext;

    //
    // Dump Plain Text
    //
    std::cout << "Plain Text (" << plaintext.size() << " bytes)" << std::endl;
    std::cout << plaintext;
    std::cout << std::endl << std::endl;

    //
    // Create Cipher Text
    //
    CryptoPP::AES::Encryption aesEncryption(key, CryptoPP::AES::DEFAULT_KEYLENGTH);
    CryptoPP::CBC_Mode_ExternalCipher::Encryption cbcEncryption( aesEncryption, iv );

    CryptoPP::StreamTransformationFilter stfEncryptor(cbcEncryption, new CryptoPP::StringSink( ciphertext ) );
    stfEncryptor.Put( reinterpret_cast<const unsigned char*>( plaintext.c_str() ), plaintext.length() + 1 );
    stfEncryptor.MessageEnd();

    //
    // Dump Cipher Text
    //
    std::cout << "Cipher Text (" << ciphertext.size() << " bytes)" << std::endl;

    for( int i = 0; i < ciphertext.size(); i++ ) {

        std::cout << "0x" << std::hex << (0xFF & static_cast<byte>(ciphertext[i])) << " ";
    }

    std::cout << std::endl << std::endl;

    //
    // Decrypt
    //
    CryptoPP::AES::Decryption aesDecryption(key, CryptoPP::AES::DEFAULT_KEYLENGTH);
    CryptoPP::CBC_Mode_ExternalCipher::Decryption cbcDecryption( aesDecryption, iv );

    CryptoPP::StreamTransformationFilter stfDecryptor(cbcDecryption, new CryptoPP::StringSink( decryptedtext ) );
    stfDecryptor.Put( reinterpret_cast<const unsigned char*>( ciphertext.c_str() ), ciphertext.size() );
    stfDecryptor.MessageEnd();

    //
    // Dump Decrypted Text
    //
    std::cout << "Decrypted Text: " << std::endl;
    std::cout << decryptedtext;
    std::cout << std::endl << std::endl;

    return 0;
}

Descriptions of the modes given above can be found at the following wikipedia page:

http://en.wikipedia.org/wiki/Cipher_block_chaining

// Runtime Includes
#include <iostream>

// Crypto++ Includes
#include "cryptlib.h"
#include "modes.h"      // xxx_Mode< >
#include "filters.h"    // StringSource and
                        // StreamTransformation


// Cipher Modes
//
// #define CIPHER_MODE CBC_CTS_Mode
// #define CIPHER_MODE CBC_Mode
// #define CIPHER_MODE CFB_FIPS_Mode
#define CIPHER_MODE CFB_Mode
// #define CIPHER_MODE CTR_Mode
// #define CIPHER_MODE ECB_Mode
// #define CIPHER_MODE OFB_Mode

// Ciphers
//
// #define CIPHER AES
// #define CIPHER Blowfish
// #define CIPHER BTEA
// #define CIPHER Camellia
// #define CIPHER CAST128
// #define CIPHER CAST256
// #define CIPHER DES
// #define CIPHER DES_EDE2
#define CIPHER DES_EDE3
// #define CIPHER DES_XEX3
// #define CIPHER GOST
// #define CIPHER IDEA
// #define CIPHER MARS
// #define CIPHER RC2
// #define CIPHER RC5
// #define CIPHER RC6
// #define CIPHER Rijndael
// #define CIPHER SAFER_K
// #define CIPHER SAFER_SK
// #define CIPHER Serpent
// #define CIPHER SHACAL2
// #define CIPHER SHARK
// #define CIPHER SKIPJACK
// #define CIPHER ThreeWay
// #define CIPHER Twofish
// #define CIPHER XTEA

int main(int argc, char* argv[]) {
    
    // Key and IV setup
    byte key[ CryptoPP::CIPHER::DEFAULT_KEYLENGTH ], 
          iv[ CryptoPP::CIPHER::BLOCKSIZE ];

    ::memset( key, 0x01, CryptoPP::CIPHER::DEFAULT_KEYLENGTH );
    ::memset(  iv, 0x01, CryptoPP::CIPHER::BLOCKSIZE );

    // Message M
    std::string PlainText = "Hello World";

    // Cipher Text Sink
    std::string CipherText;

    // Encryptor
    CryptoPP::CIPHER_MODECryptoPP::CIPHER::Encryption
        Encryptor( key, sizeof(key), iv );

    // Encryption
    CryptoPP::StringSource( PlainText, true,
        new CryptoPP::StreamTransformationFilter( Encryptor,
            new CryptoPP::StringSink( CipherText )
        ) // StreamTransformationFilter
    ); // StringSource

    ///////////////////////////////////////
    //                DMZ                //
    ///////////////////////////////////////

    // Recovered Text Sink
    std::string RecoveredText;

    // Decryptor
    CryptoPP::CIPHER_MODECryptoPP::CIPHER::Decryption
        Decryptor( key, sizeof(key), iv );

    // Decryption
    CryptoPP::StringSource( CipherText, true,
        new CryptoPP::StreamTransformationFilter( Decryptor,
            new CryptoPP::StringSink( RecoveredText )
        ) // StreamTransformationFilter
    ); // StringSource

    //////////////////////////////////////////
    //                Output                //
    //////////////////////////////////////////

    std::cout << "Algorithm:" << std::endl;
    std::cout << "  " << Encryptor.AlgorithmName() << std::endl;
    std::cout << "Minimum Key Size:" << std::endl;
    std::cout << "  " << Encryptor.MinKeyLength() << " bytes" << std::endl;
    std::cout << std::endl;

    std::cout << "Plain Text (" << PlainText.length() << " bytes)" << std::endl;
    std::cout << "  '" << PlainText << "'" << std::endl;
    std::cout << std::endl;

    std::cout << "Recovered Text:" << std::endl;
    std::cout << "  '" << RecoveredText << "'" << std::endl;
    std::cout << std::endl;

    return 0;
}