Pourquoi certains manipulateurs C affichent-ils un comportement « collant » ?

Les manipulateurs et leur nature « collante » en C

En C , certains manipulateurs iomanip présentent un comportement connu sous le nom de « collant », dans lequel ils continuent d'influencer le flux jusqu'à ce que explicitement réinitialisé. Ce comportement peut conduire à des résultats inattendus, comme le montre l'extrait de code suivant :

std::stringstream ss;
ss.fill('0'); ss.setf(ios::right, ios::adjustfield);
ss << setw(2) << timestruct.tm_mday;
ss << timestruct.tm_hour;
ss << timestruct.tm_min;
std::string filingTime = ss.str(); // BAD: '0794'

Dans cet exemple, nous nous attendons à ce que le manipulateur setw() formate le champ tm_mday avec une largeur de 2 et justifie à droite. la sortie. Cependant, tm_hour et tm_min sont imprimés sans aucun formatage. En effet, setw() n'est pas un manipulateur « collant », ce qui signifie qu'il n'affecte que la prochaine opération d'insertion.

Quels manipulateurs sont collants ?

Sur la base de la discussion dans les commentaires, ce qui suit les manipulateurs sont classés comme 'sticky' :

• setiosflags
• resetiosflags
• setbase
• setfill
• setprecision

Ces manipulateurs renvoient tous un objet plutôt qu'un flux, indiquant qu'ils effectuent une opération uniquement sur le prochain objet à insérer dans le flux.

Non collant Manipulateurs

• [no]boolalpha
• [no]showbase
• [no]showpoint
• [no]showpos
• [no]skipws
• [no]unitbuf
• [no]majuscule
• déc/hex/oct
• fixe/scientifique
• interne/gauche/droite
• ws/endl /ends/flush

Ces les manipulateurs effectuent des opérations sur le flux lui-même, sans affecter son état pour les opérations ultérieures.

L'exception : setw()

Notamment, setw() est le seul manipulateur qui semble se comporter différemment sur le flux. système de l'auteur. Bien qu'il ne s'agisse pas d'un manipulateur « collant », il peut se comporter comme tel en utilisant des objets au format personnalisé, comme démontré dans le code suivant :

#include <iostream>
#include <iomanip>

struct SquareBracktAroundNextItem
{
    SquareBracktAroundNextItem(std::ostream& str) : m_str(str) {}
    std::ostream& m_str;
};

struct PutSquareBracket {};

SquareBracktAroundNextItem operator<<(std::ostream& str, PutSquareBracket const& data)
{
    return SquareBracktAroundNextItem(str);
}

template<typename T>
std::ostream& operator<<(SquareBracktAroundNextItem const& bracket, T const& data)
{
    std::ios_base::fmtflags flags = bracket.m_str.flags();
    std::streamsize currentPrecision = bracket.m_str.precision();

    bracket.m_str << '[' << std::fixed << std::setprecision(10) << data << std::setprecision(currentPrecision) << ']';

    bracket.m_str.flags(flags);

    return bracket.m_str;
}

int main()
{
    std::cout << 5.34 << "\n"                        // Before
              << PutSquareBracket() << 5.34 << "\n"  // Temp change settings.
              << 5.34 << "\n";                       // After
}

Sortie :

5.34
[5.3400000000]
5.34

En résumé, la plupart des manipulateurs iomanip en C sont « collants », ce qui signifie qu'ils continuent d'affecter le flux jusqu'à ce qu'ils soient explicitement réinitialisés. setw() est l'exception notable, mais il peut être rendu « collant » à l'aide d'objets de format personnalisé.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!