一种程序设计语言（指Ｃ++或Ｃ）与它们所提供的函数的关系？

Question

１、语言=语句命令＋函数吗？（表面上的概括） , 那命令和函数的关系是什么？２、像c或c++如果在没有提供任何标准或内置函数的情况下，它还算不算编程语言，还可不可以编程如：程序员自己可以写出strcpy的函数，但malloc怎么写出来呢？但又是什么语言写的呢？如果是其它方法写的话是不是应该与strcpy之数的函数区分开？

Answer 1

语言提供一种编程的规范，
函数是你遵循这种规范来写的，
strcpy你可以写，malloc你也可以写，如果你仔细看过谭浩强的c程序设计就会对malloc有个明白，其实这要用到操作系统对程序内存的分配，其实大致原理是一样，不明白可以慢慢来，
其实C中提供的库函数你可以实现，只要你足够年，OK
看来你是个初学者

Answer 2

１、你是说在一个函数都没有的情况下，只要有语法、命令这些规范，理论上就是可以编程的，也就是说作为一个程序员最终都是有办法写程序的？２、命令与函数的区别？　如：　exit() 和printf() 还有strcpy(),如果命令就是函数的话，那c,c++就剩下while ,continue,int ...如你所说的规范性的东西，看你怎么编程？
如：我要在屏幕上打印出字符，没有printf()，你会怎么搞？

Answer 3

如果你懂编译原理的话你应该可以回答得出来（我不懂，没机会学）我认为c或c++中的某些内置函数，是用c或c++无法实现的.

Answer 4

语言是一种逻辑,针对这种逻辑产生了很多编程方法，或者说编程模型.比如C,如果去掉库函数,那么C语言就退化成了,for,while ,goto,++,--之类的关键字和操作符这种东西,也正是它们才说明了这种逻辑.但语言的目的还不是为了更好的写程序,开发软件或系统.所以,语言标准就当然的规定了些库函数，供程序员使用.这是本人的理解.建议LZ看看C或C++标准

Answer 5

请问：爱之风printf()是怎么编出来的？给个思路也可以？

Answer 6

http://www.chinaspx.com/archive/develop/18135.htm
  这个上面有说明很清楚的..你可以看看就知道了
给你一段代码.
你可以看看关于printf 是怎么写出来的
int _xoutput (
    BYTE *strbuf,
    const char *format,
    va_list argptr
    )
{
    int hexadd;     // offset to add to number to get 'a'..'f' 
    char ch;       // character just read 
    int flags;      // flag word -- see #defines above for flag values 
    int state;   // current state 
    char chclass; // class of current character 
    int radix;      // current conversion radix 
    int charsout;   // characters currently written so far, -1 = IO error 
    //int fldwidth;   // selected field width -- 0 means default 
    int precision;  // selected precision  -- -1 means default 
    //char prefix[2];    // numeric prefix -- up to two characters 
    //int prefixlen;  // length of prefix -- 0 means no prefix 
    //int capexp;     // non-zero = 'E' exponent signifient, zero = 'e' 
    //int no_xoutput;  // non-zero = prodcue no output for this specifier 
    union {
        char *sz;   // pointer text to be printed, not zero terminated 
    } text;
    int textlen;    // length of the text in bytes/wchars to be printed.
                       //textlen is in multibyte or wide chars if _UNICODE 
    union {
        char sz[BUFFERSIZE];
    } buffer;
    //wchar_t wchar;      // temp wchar_t 
    //int bufferiswide;   // non-zero = buffer contains wide chars already  m_pStrBuf=strbuf;
    textlen = 0;        // no text yet 
    charsout = 0;       // no characters written yet 
    state = ST_NORMAL;  // starting state     // main loop -- loop while format character exist and no I/O errors 
    while ((ch = *format++) != '\0' && charsout >= 0) {
        chclass = xfind_char_class(ch);  // find character class 
        state = xfind_next_state(chclass, state); // find next state         // execute code for each state 
        switch (state) {        case ST_NORMAL:
            // normal state -- just write character 
            //bufferiswide = 0;
            XWRITE_CHAR(ch, &charsout);
continue;        case ST_PERCENT:
            // set default value of conversion parameters 
            //prefixlen = fldwidth = no_xoutput = capexp = 0;
            flags = 0;
            precision = -1;
            //bufferiswide = 0;   // default 
continue;        case ST_SIZE:
            // just read a size specifier, set the flags based on it 
            switch (ch) {
            case SELF('l'):
                flags |= FL_LONG;   // 'l' => long int or wchar_t 
                break;
            case SELF('h'):
                flags |= FL_SHORT;  // 'h' => short int or char 
                break;
}
continue;

case ST_TYPE:
            switch (ch) {
            case SELF('c'):
XWRITE_CHAR(xget_char_arg(&argptr),&charsout);
continue;            case SELF('s'):{
                char *pStr;
                pStr = xget_ptr_arg(&argptr);
XWRITE_STRING(pStr,strlen(pStr),&charsout);
   }
continue;            case SELF('d'):
            case SELF('i'):
                // signed decimal output 
                flags |= FL_SIGNED;
                radix = 10;
                goto COMMON_INT;            case SELF('u'):
                radix = 10;
                goto COMMON_INT;            case SELF('X'):
                // unsigned upper hex output 
                hexadd = SELF('A') - SELF('9') - 1;     // set hexadd for uppercase hex 
                goto COMMON_HEX;            case SELF('x'):
                // unsigned lower hex output 
                hexadd = SELF('a') - SELF('9') - 1;     // set hexadd for lowercase hex 
                // DROP THROUGH TO COMMON_HEX             COMMON_HEX:
                radix = 16;
                if (flags & FL_ALTERNATE) {
                    // alternate form means '0x' prefix 
                    //prefix[0] = SELF('0');
                    //prefix[1] = (char)(SELF('x') - SELF('a') + SELF('9') + 1 + hexadd);  // 'x' or 'X' 
                    //prefixlen = 2;
                }
                goto COMMON_INT;
            COMMON_INT: {
                // This is the general integer formatting routine. 
                // Basically, we get an argument, make it positive 
                // if necessary, and convert it according to the 
                // correct radix, setting text and textlen 
                // appropriately.                 unsigned long number;   // number to convert 
                int digit;              // ascii value of digit 
                long l;                 // temp long value 
                if (flags & FL_SHORT) {
                    if (flags & FL_SIGNED)
                        l = (short) xget_int_arg(&argptr); // sign extend 
                    else
                        l = (unsigned short) xget_int_arg(&argptr);    // zero-extend
                }else{
                    if (flags & FL_SIGNED)
                        l = xget_int_arg(&argptr); // sign extend 
                    else
                        l = (unsigned int) xget_int_arg(&argptr);    // zero-extend
                }                // 2. check for negative; copy into number 
                if ( (flags & FL_SIGNED) && l < 0) {
                    number = -l;
                    flags |= FL_NEGATIVE;   // remember negative sign 
                } else {
                    number = l;
                }
                // 3. check precision value for default; non-default 
                //    turns off 0 flag, according to ANSI. 
                if (precision < 0)
                    precision = 1;  // default precision 
                else
                    flags &= ~FL_LEADZERO;                // 4. Check if data is 0; if so, turn off hex prefix 
                if (number == 0)
;
                    //prefixlen = 0;                // 5. Convert data to ASCII -- note if precision is zero 
                //    and number is zero, we get no digits at all.                       text.sz = &buffer.sz[BUFFERSIZE-1];    // last digit at end of buffer                 while (precision-- > 0 || number != 0) {
                    digit = (int)(number % radix) + '0';
                    number /= radix;                // reduce number 
                    if (digit > '9') {
                        // a hex digit, make it a letter 
                        digit += hexadd;
                    }
                    *text.sz-- = (char)digit;       // store the digit 
                }                textlen = (char *)&buffer.sz[BUFFERSIZE-1] - text.sz; // compute length of number 
                ++text.sz;          // text points to first digit now 
                // 6. Force a leading zero if FORCEOCTAL flag set 
                if ((flags & FL_FORCEOCTAL) && (text.sz[0] != '0' || textlen == 0)) {
                    *--text.sz = '0';
                    ++textlen;      // add a zero 
                }
            }
            break;
}//end switch
            XWRITE_STRING(text.sz, textlen, &charsout);
break;
default:
continue;
        }//switch(state)
    }
m_pStrBuf[charsout]=0;
//$$printf("charsout=%u\n",charsout);
    return charsout;        // return value = number of characters written 
}
int xprintf(BYTE *strbuf, char const *fmt, ...)
{
 int ret;
 va_list ap;
 //FILE f;  //$$f._flags = __SWR | __SSTR;
 //$$f._bf._base = f._p = (unsigned char *)str;
 //$$f._bf._size = f._w = INT_MAX;
 va_start(ap, fmt);//"这是一个宏"
 //ret = _xoutput(&f,fmt,ap );
 ret = _xoutput(strbuf,fmt,ap );
 //ret = _output(&f,fmt,ap );
 va_end(ap);//"这是一个宏"
 //$$*f._p = 0;
 return (ret);
}

Answer 7

当然这只是模拟一个printf函数，并不是真正的实现！printf实现思路就是这样的！

Answer 8

请看unix与linux下printf的实现[转帖]：http://www.csdn.net/develop/article/21/21348.shtm