std::ios_base::xalloc

 

C++

Apoyo de compiladores

Implementaciones independientes y albergadas

Lenguaje

Biblioteca estándar

Encabezados de la biblioteca estándar

Requisitos denominados

Macros de prueba de característica (C++20)

Biblioteca de apoyo del lenguaje

Biblioteca de conceptos (C++20)

Biblioteca de diagnósticos

Biblioteca de gestión de memoria

Biblioteca de metaprogramación (C++11)

Biblioteca de servicios generales

Biblioteca de contenedores

Biblioteca de iteradores

Biblioteca de rangos (C++20)

Biblioteca de algoritmos

Biblioteca de cadenas

Biblioteca de procesamiento de texto

Biblioteca numérica

Biblioteca de fecha y hora

Biblioteca de entrada/salida

Biblioteca del sistema de archivos (C++17)

Biblioteca de apoyo de concurrencia (C++11)

Biblioteca de apoyo de ejecución (C++26)

Especificaciones técnicas

Índice de símbolos

Bibliotecas externas

 

Biblioteca de E/S

Manipuladores de E/S

E/S estilo C

Búferes

basic_streambuf

basic_filebuf

basic_stringbuf

strstreambuf (en desuso en C++98)

basic_syncbuf (C++20)

Flujos

Abstracciones

ios_base

basic_ios

basic_istream

basic_ostream

basic_iostream

E/S de archivos

basic_ifstream

basic_ofstream

basic_fstream

E/S de cadenas

basic_istringstream

basic_ostringstream

basic_stringstream

E/S de arrays

istrstream (en desuso en C++98)

ostrstream (en desuso en C++98)

strstream (en desuso en C++98)

Salida sincronizada

basic_osyncstream (C++20)

Tipos

streamoff

streamsize

fpos

Interfaz de categoría de error

iostream_category (C++11)

io_errc (C++11)

 

std::ios_base

Funciones miembro

ios_base::ios_base

ios_base::~ios_base

ios_base::operator=

Formato

ios_base::flags

ios_base::setf

ios_base::unsetf

ios_base::precision

ios_base::width

Configuración regional

ios_base::imbue

ios_base::getloc

Array interno extensible

ios_base::xalloc

ios_base::iword

ios_base::pword

Misceláneos

ios_base::register_callback

ios_base::sync_with_stdio

Clases miembro

ios_base::failure

ios_base::Init

Tipos miembro

ios_base::openmode

ios_base::fmtflags

ios_base::iostate

ios_base::seekdir

ios_base::event

ios_base::event_callback

 

static int xalloc();

Devuelve un valor de índice único (para todo el programa) que se puede utilizar para acceder a un elemento long y un elemento void* en el almacenamiento privado de std::ios_base llamando a iword() y pword(). La llamada a xalloc no asigna memoria.

Esta función es segura para hilos; el acceso simultáneo de varios hilos no da como resultado una carrera de datos. (desde C++14)

Incrementa efectivamente un dato miembro estático privado de std::ios_base, como si se ejecutara return index++;, si index es el nombre de ese miembro estático (que puede ser std::atomic para admitir el acceso simultáneo de varios hilos o sincronizarse de otro modo) (desde C++14).

Parámetros

(Ninguno)

Valor de retorno

Un entero único para usar como índice de pword/iword.

Ejemplo

Utiliza el almacenamiento en pword de la clase base para identificación de tipos en tiempo de ejecución de objetos flujo derivados.

Ejecuta este código

#include <iostream>
 
template<class CharT, class Traits = std::char_traits<CharT> >
class mi_flujo : public std::basic_ostream<CharT, Traits>
{
public:
    static const int xindex;
 
    mi_flujo(std::basic_ostream<CharT, Traits>& ostr) :
        std::basic_ostream<CharT, Traits>(ostr.rdbuf())
    {
        this->pword(xindex) = this;
    }
 
    void mi_funcion()
    {
        *this << "[manejo especial para mi_flujo]";
    }
};
 
// Cada especialización de mi_flujo obtiene un índice único de xalloc()
template<class CharT, class Traits>
const int mi_flujo<CharT, Traits>::xindex = std::ios_base::xalloc();
 
// Este manipulador de E/S podrá reconocer ostreams que sean de tipo mi_flujo
// buscando el puntero almacenado en pword.
template<class CharT, class Traits>
std::basic_ostream<CharT, Traits>& mi_manipulador(std::basic_ostream<CharT, Traits>& os)
{
    if (os.pword(mi_flujo<CharT, Traits>::xindex) == &os)
        static_cast<mi_flujo<CharT, Traits>&>(os).mi_funcion();
    return os;
}
 
int main()
{
    std::cout << "cout, prueba de caracteres estrechos  " << mi_manipulador << '\n';
 
    mi_flujo<char> mi_salida(std::cout);
    mi_salida << "mi_salida, prueba de caracteres estrechos  " << mi_manipulador << '\n';
 
    std::wcout << "wcout, prueba de caracteres anchos  " << mi_manipulador << '\n';
 
    mi_flujo<wchar_t> mi_salida_ancha(std::wcout);
    mi_salida_ancha << "mi_salida_ancha, prueba de caracteres anchos  " << mi_manipulador << '\n';
}

Salida:

cout, prueba de caracteres estrechos 
mi_salida, prueba de caracteres estrechos  [manejo especial para mi_flujo]
wcout, prueba de caracteres anchos 
mi_salida_ancha, prueba de caracteres anchos  [manejo especial para mi_flujo]

Véase también

pword	Cambia el tamaño del almacenamiento privado si es necesario y el acceso al elemento void* en el índice dado. (función miembro pública)
iword	Cambia el tamaño del almacenamiento privado si es necesario y accede al elemento long en el índice dado. (función miembro pública)