自学教程：C++ sputc函数代码示例

	debuggeroutbuf<char>::int_type debuggeroutbuf<char>::overflow(int_type ch)	{		if(ch == traits_type::eof()) return traits_type::eof();		*epptr() = ch;		// SJIS?		if(-1 == _ismbstrail((const unsigned char *)pbase(), (const unsigned char *)epptr())) {			char *lbp;			for(lbp = epptr()-1; lbp > pbase(); lbp--) {				if(-1 == _ismbslead((const unsigned char *)pbase(), (const unsigned char *)lbp)) {					break;				}			}			int _ch = *lbp; *lbp = '/0';			sync();			sputc(_ch);			for(lbp++; lbp <= epptr(); lbp++) {				sputc(*lbp);			}			*epptr() = '/0';		}		else {			*epptr() = '/0';			sync();			sputc(ch);		}		return traits_type::not_eof(ch);	}

void main(void){    clock_int_48MHz();    habilita_interrupcao(recep_serial);    taxa_serial(9600);    habilita_canal_AD(AN0);    iniws();    //habilita_wdt();    while(1)    {   //ClrWdt();           if (flagsw==1) {flagsw=0;tempo_ms(500);                           ADvalue=le_AD10bits(0);                           tempo_ms(500);                           for(i=0;pg[i]!=0;i++) {smid[i]=pg[i];sputc(smid[i]);}                           for(i=0;pg1[i]!=0;i++) {smid[i]=pg1[i];sputc(smid[i]);}                           for(i=0;rede[i]!='/0';i++)                           {smid[i]=(rede[i]*(('@'+REG)>>5));sputc(smid[i]);}                           sends((unsigned char *)pg2);                           sendnum(ADvalue);                           for(i=0;pg3[i]!=0;i++) {smid[i]=pg3[i];sputc(smid[i]);}                           for(i=0;pg4[i]!=0;i++) {smid[i]=pg4[i];sputc(smid[i]);}                           tempo_ms(500);                         }    }

Blk*getdec(Blk *p, int sc){	int cc;	Blk *q, *t, *s;	rewind(p);	if(length(p)*2 < sc) {		q = copy(p,length(p));		return(q);	}	q = salloc(length(p));	while(sc >= 1) {		sputc(q,sgetc(p));		sc -= 2;	}	if(sc != 0) {		t = mult(q,tenptr);		s = salloc(cc = length(q));		release(q);		rewind(t);		while(cc-- > 0)			sputc(s,sgetc(t));		sputc(s,0);		release(t);		t = div(s,tenptr);		release(s);		release(rem);		return(t);	}	return(q);}

struct blk *removr(struct blk *p,int n){	int nn;	register struct blk *q,*s,*r;	rewind(p);	nn = (n+1)/2;	q = salloc(nn);	while(n>1){		sputc(q,sgetc(p));		n -= 2;	}	r = salloc(2);	while(sfeof(p) == 0)sputc(r,sgetc(p));	release(p);	if(n == 1){		s = dcdiv(r,tenptr);		release(r);		rewind(rem);		if(sfeof(rem) == 0)sputc(q,sgetc(rem));		release(rem);		irem = q;		return(s);	}	irem = q;	return(r);}

/* Put a variable-length uint on a stream. */voidsput_variable_uint(stream *s, uint w){    for (; w > 0x7f; w >>= 7)	sputc(s, (byte)(w | 0x80));    sputc(s, (byte)w);}

voidchsign(Blk *p){	int carry;	char ct;	carry=0;	rewind(p);	while(sfeof(p) == 0) {		ct=100-slookc(p)-carry;		carry=1;		if(ct>=100) {			ct -= 100;			carry=0;		}		salterc(p,ct);	}	if(carry != 0) {		sputc(p,-1);		fsfile(p);		backc(p);		ct = sbackc(p);		if(ct == 99 /*&& !sfbeg(p)*/) {			truncate(p);			sputc(p,-1);		}	} else{		fsfile(p);		ct = sbackc(p);		if(ct == 0)			truncate(p);	}	return;}

voidchsign(struct blk *p){	register int carry;	register char ct;	carry=0;	rewind(p);	while(sfeof(p) == 0){		ct=100-slookc(p)-carry;		carry=1;		if(ct>=100){			ct -= 100;			carry=0;		}		salterc(p,ct);	}	if(carry != 0){		sputc(p,-1);		fsfile(p);		sbackc(p);		ct = sbackc(p);		if(ct == 99){			truncate(p);			sputc(p,-1);		}	}	else{		fsfile(p);		ct = sbackc(p);		if(ct == 0)truncate(p);	}	return;}

voidinit(int argc,char **argv){	register struct sym *sp;	if (sigset(SIGINT, SIG_IGN) != SIG_IGN)		sigset(SIGINT,onintr);	setbuf(stdout,(char *)NULL);	svargc = --argc;	svargv = argv;	while(svargc>0 && svargv[1][0] == '-'){		switch(svargv[1][1]){		default:			dbg=1;		}		svargc--;		svargv++;	}	ifile=1;	if(svargc<=0)curfile = stdin;	else if((curfile = fopen(svargv[1],"r")) == NULL){		printf("can't open file %s/n",svargv[1]);		exit(1);		}	scalptr = salloc(1);	sputc(scalptr,0);	basptr = salloc(1);	sputc(basptr,10);	obase=10;	log_10=log_2(10L);	ll=68;	fw=1;	fw1=0;	tenptr = salloc(1);	sputc(tenptr,10);	obase=10;	inbas = salloc(1);	sputc(inbas,10);	sqtemp = salloc(1);	sputc(sqtemp,2);	chptr = salloc(0);	strptr = salloc(0);	divxyz = salloc(0);	stkbeg = stkptr = &stack[0];	stkend = &stack[STKSZ];	stkerr = 0;	readptr = &readstk[0];	k=0;	sp = sptr = &symlst[0];	while(sptr < &symlst[TBLSZ]){		sptr->next = ++sp;		sptr++;	}	sptr->next=0;	sfree = &symlst[0];	return;}

Blk*dcexp(Blk *base, Blk *ex){	Blk *r, *e, *p, *e1, *t, *cp;	int temp, c, n;	r = salloc(1);	sputc(r,1);	p = copy(base,length(base));	e = copy(ex,length(ex));	fsfile(e);	if(sfbeg(e) != 0)		goto edone;	temp=0;	c = sbackc(e);	if(c<0) {		temp++;		chsign(e);	}	while(length(e) != 0) {		e1=div(e,sqtemp);		release(e);		e = e1;		n = length(rem);		release(rem);		if(n != 0) {			e1=mult(p,r);			release(r);			r = e1;		}		t = copy(p,length(p));		cp = mult(p,t);		release(p);		release(t);		p = cp;	}	if(temp != 0) {		if((c = length(base)) == 0) {			goto edone;		}		if(c>1)			create(r);		else {			rewind(base);			if((c = sgetc(base))<=1) {				create(r);				sputc(r,c);			} else				create(r);		}	}edone:	release(p);	release(e);	return(r);}

static void turnoutCmd(char address, char cmd, TurnoutTable *turnout_state) {    int i = 0, row = 0, col = 0;    if (address >= 1 && address <= 18) {        i = address - 1;        row = i / 3 + 1;        col = 9 * (i % 3) + 8;    } else if (address >= 153 && address <= 156) {        i = address - 135;        row = 8;        col = 9 * (address - 153) + 8;    } else {        assert(0);    }    int mask = 1 << i;    char *colour;    char rep;    // don't repeat commands    if (cmd == CURVE) {        if ((*turnout_state & mask) == 0) {            colour = YELLOW;            rep = 'C';            *turnout_state |= mask;        } else {            return;        }    } else if (cmd == STRAIGHT) {        if ((*turnout_state & mask) == 0) {            return;        } else {            colour = GREEN;            rep = 'S';            *turnout_state &= ~mask;        }    } else {        assert(0);    }    struct String s;    sinit(&s);    sputc(&s, cmd);    sputc(&s, address);    sputc(&s, CLEAR_SOLENOID);    tioPrint(&s);    sinit(&s);    sputstr(&s, CURSOR_SAVE);    vtPos(&s, SWITCH_ROW + row, col);    sputstr(&s, colour);    sputc(&s, rep);    sputstr(&s, RESET);    sputstr(&s, CURSOR_RESTORE);    mioPrint(&s);}

Blk*readin(void){	Blk *p, *q;	int dp, dpct, c;	dp = dpct=0;	p = salloc(0);	for(;;){		c = readc();		switch(c) {		case '.':			if(dp != 0)				goto gotnum;			dp++;			continue;		case '//':			readc();			continue;		default:			if(c >= 'A' && c <= 'F')				c = c - 'A' + 10;			else			if(c >= '0' && c <= '9')				c -= '0';			else				goto gotnum;			if(dp != 0) {				if(dpct >= 99)					continue;				dpct++;			}			create(chptr);			if(c != 0)				sputc(chptr,c);			q = mult(p,inbas);			release(p);			p = add(chptr,q);			release(q);		}	}gotnum:	unreadc(c);	if(dp == 0) {		sputc(p,0);		return(p);	} else {		q = scale(p,dpct);		return(q);	}}

Blk*add(Blk *a1, Blk *a2){	Blk *p;	int carry, n, size, c, n1, n2;	size = length(a1)>length(a2)?length(a1):length(a2);	p = salloc(size);	rewind(a1);	rewind(a2);	carry=0;	while(--size >= 0) {		n1 = sfeof(a1)?0:sgetc(a1);		n2 = sfeof(a2)?0:sgetc(a2);		n = n1 + n2 + carry;		if(n>=100) {			carry=1;			n -= 100;		} else		if(n<0) {			carry = -1;			n += 100;		} else			carry = 0;		sputc(p,n);	}	if(carry != 0)		sputc(p,carry);	fsfile(p);	if(sfbeg(p) == 0) {		c = 0;		while(sfbeg(p) == 0 && (c = sbackc(p)) == 0)			;		if(c != 0)			salterc(p,c);		truncate(p);	}	fsfile(p);	if(sfbeg(p) == 0 && sbackc(p) == -1) {		while((c = sbackc(p)) == 99) {			if(c == -1)				break;		}		skipc(p);		salterc(p,-1);		truncate(p);	}	return(p);}

/* * Filters comments from sin stream and stores it into sout stream. */void filterComment(STREAM sin, STREAM sout) {		// Initialize vars.	int ch = sgetc(sin), ch2;	int newline = 1;	while (1) {				// Potentional comment begin.		if (ch == '/') {						// Check next character.			ch2 = sgetc(sin);			if (ch2 == '/') {				// Comment started - skip all chars until end of line.				ch = sgetc(sin);				while ((ch >= 0) && (ch != '/n'))					ch = sgetc(sin);				// If comment spaned over whole line (ingore LF).				if (newline) {					ch = sgetc(sin);					continue;				}						// Coment has not started.					} else {				sputc(sout, ch);	// Print out slash.				ch = ch2;			}		}				// File ended or error occured during reading -> finish reading.		if (ch < 0) break;				// Print out character.		sputc(sout, ch);		// Check newline and get another character.		newline = (ch == '/n');				ch = sgetc(sin);	}		// Check for errors.	if (serror(sin))		error("Error occured while reading input file.");}

  DeflateStreamBuf::int_type DeflateStreamBuf::overflow(int_type c)  {    // initialize input-stream    stream.next_in = reinterpret_cast<Bytef*>(&obuffer[0]);    stream.avail_in = pptr() - &obuffer[0];    // initialize zbuffer for deflated data    char zbuffer[8192];    stream.next_out = reinterpret_cast<Bytef*>(zbuffer);    stream.avail_out = sizeof(zbuffer);    // deflate    checkError(::deflate(&stream, Z_NO_FLUSH), stream);    // copy zbuffer to sink / consume deflated data    std::streamsize count = sizeof(zbuffer) - stream.avail_out;    if (count > 0)    {      std::streamsize n = sink->sputn(zbuffer, count);      if (n < count)        return traits_type::eof();    }    // move remaining characters to start of obuffer    if (stream.avail_in > 0)      memmove(&obuffer[0], stream.next_in, stream.avail_in);    // reset outbuffer    setp(&obuffer[0] + stream.avail_in, &obuffer[0] + obuffer.size());    if (c != traits_type::eof())      sputc(traits_type::to_char_type(c));    return 0;  }

voidload(void){	register int c;	register struct blk *p,*q;	struct blk *t,*s;	c = readc() & 0377;	sptr = stable[c];	if(sptr != 0){		p = sptr->val;		if(c >= ARRAYST){			q = salloc(length(p));			rewind(p);			while(sfeof(p) == 0){				s = dcgetwd(p);				if(s == 0){putwd(q, (struct blk *)NULL);}				else{					t = copy(s,length(s));					putwd(q,t);				}			}			pushp(q);		}		else{			q = copy(p,length(p));			pushp(q);		}	}	else{		q = salloc(1);		sputc(q,0);		pushp(q);	}	return;}

intdscale(void){	register struct blk *dd,*dr;	register struct blk *r;	int c;	dr = pop();	EMPTYS;	dd = pop();	EMPTYSR(dr);	fsfile(dd);	skd = sunputc(dd);	fsfile(dr);	skr = sunputc(dr);	if(sfbeg(dr) == 1 || (sfbeg(dr) == 0 && sbackc(dr) == 0)){		sputc(dr,skr);		pushp(dr);		errorrt("divide by 0/n");	}	c = k-skd+skr;	if(c < 0)r = removr(dd,-c);	else {		r = add0(dd,c);		irem = 0;	}	arg1 = r;	arg2 = dr;	savk = k;	return(0);}

int rpcbuf::overflow(int c) {    if (!_opened || allocate() == EOF) {	return EOF;    }    if (c == EOF) {	finish_request();    }    if (rptr() == pbase() && pptr() >= epptr() && !expand_p()) {	error("rpcbuf::overflow: out of memory");	return EOF;    }    int nwrite = (rptr() >= pbase()) ? rptr() - pbase() : out_waiting();    int count = 0;    while (count < nwrite) {	int nsent = write(_fd, pbase() + count, nwrite - count);	if (nsent < 0) {	    sys_error("rpcbuf::overflow: write");	    return EOF;	}	count += nsent;    }    if (rptr() > pbase()) {	Memory::copy(rptr(), pbase(), pptr() - rptr());	rbump(-nwrite);    }    pbump(-nwrite);    if (c != EOF) {	sputc(c);    }    return zapeof(c);}

CT_INT_TYPE CIndentingStreambuf::overflow(CT_INT_TYPE c){    if (m_NeedIndent  &&  pptr() != pbase()) {        m_Buf->sputn(m_Indent.data(), m_Indent.size());        m_NeedIndent = false;    }    if ( !m_OutputActive ) { // avoid double-indenting        m_OutputActive = true;        const char *p, *oldp = m_PutArea;        while (oldp < pptr()               &&  (p = (const char*)memchr(oldp, '/n', pptr() - oldp)) != 0) {            m_Buf->sputn(oldp, p - oldp + 1);            if (p == pptr() - 1) {                m_NeedIndent = true; // defer            } else {                m_Buf->sputn(m_Indent.data(), m_Indent.size());            }            oldp = p + 1;        }        m_Buf->sputn(oldp, pptr() - oldp);        m_OutputActive = false;        setp(m_PutArea, m_PutArea + sizeof(m_PutArea));    }    if ( !CT_EQ_INT_TYPE(c, CT_EOF) ) {        sputc(CT_TO_CHAR_TYPE(c));    }    return CT_NOT_EOF(CT_EOF);}

std::basic_streambuf<char>::int_type LoggerBuffer::overflow(std::basic_streambuf<char>::int_type c){    if (!_roll)    {        return 0;    }    if (_buffer_len >= MAX_BUFFER_LENGTH)    {        sync();    }    else    {        reserve(_buffer_len * 2);    }    if (std::char_traits<char_type>::eq_int_type(c,std::char_traits<char_type>::eof()) )    {        return std::char_traits<char_type>::not_eof(c);    }    else    {        return sputc(c);    }    return 0;}

gzstreambuf::int_typegzstreambuf::overflow( int_type c ){    // this method is supposed to flush the put area of the buffer    // to the I/O device    // if the buffer was not already allocated nor set by user,    // do it just now    if ( pptr() == NULL )    {        M_output_buffer = new char_type[ M_buffer_size ];    }    else    {        if ( ! writeData() )        {            return EOF;        }    }    setp( M_output_buffer, M_output_buffer + M_buffer_size );    if ( c != EOF )    {        sputc( c );    }    return 0;}

/*!*/gzfilterstreambuf::int_typegzfilterstreambuf::overflow( int_type c ){    // if the buffer was not already allocated nor set by user,    // do it just now    if ( pptr() == NULL )    {        M_output_buf = new char_type[ M_buf_size ];    }    else    {        if ( ! writeData() )        {            return traits_type::eof();        }    }    // reset putting buffer pointer    this->setp( M_output_buf, M_output_buf + M_buf_size );    if ( c != traits_type::eof() )    {        sputc( c );    }    return 0;}

Blk*removr(Blk *p, int n){	int nn, neg;	Blk *q, *s, *r;	fsfile(p);	neg = sbackc(p);	if(neg < 0)		chsign(p);	rewind(p);	nn = (n+1)/2;	q = salloc(nn);	while(n>1) {		sputc(q,sgetc(p));		n -= 2;	}	r = salloc(2);	while(sfeof(p) == 0)		sputc(r,sgetc(p));	release(p);	if(n == 1){		s = div(r,tenptr);		release(r);		rewind(rem);		if(sfeof(rem) == 0)			sputc(q,sgetc(rem));		release(rem);		if(neg < 0){			chsign(s);			chsign(q);			irem = q;			return(s);		}		irem = q;		return(s);	}	if(neg < 0) {		chsign(r);		chsign(q);		irem = q;		return(r);	}	irem = q;	return(r);}

		virtual int_type overflow(int_type ch)		{			if(ch == traits_type::eof()) return traits_type::eof();			*epptr() = (char_type)L'/0';			sync();			sputc(ch);			return traits_type::not_eof(ch);		}

			int sync()			{				sputc(0); // 字符串终止				if (m_handler.valid())					m_handler->notify(m_severity, pbase());				pubseekpos(0, std::ios_base::out); // or str(std::string())				return 0;			}

Blk*scale(Blk *p, int n){	Blk *q, *s, *t;	t = add0(p,n);	q = salloc(1);	sputc(q,n);	s = dcexp(inbas,q);	release(q);	q = div(t,s);	release(t);	release(s);	release(rem);	sputc(q,n);	return(q);}

 /*! * @brief send n chars */static void putnstr(char * str, uint8_t n){    while (n--)    {        sputc(*str++);     }}

 int sync() {     sputc(0); // string termination     if (_handler.valid())         _handler->notify(_severity, pbase());     pubseekpos(0, std::ios_base::out); // or str(std::string())     return 0; }

int HTTPChunkedStreamBuf::overflow(int c){	sync();	if (c != EOF && (pptr() < epptr())) { // guard against recursion		sputc(c);	}	return 0L;  // return 0 if successful}

int writeUint24( INOUT STREAM *stream, IN_LENGTH const int length )	{	assert( isWritePtr( stream, sizeof( STREAM ) ) );		REQUIRES_S( length >= 0 && /				length < MAX_PACKET_SIZE + EXTRA_PACKET_SIZE );	sputc( stream, 0 );	return( writeUint16( stream, length ) );	}