C++ 的一点笔记

$CC prog1.c         //在Unix系统中编译prog1.c
#include<string>
 string current_chapter="Getting started";

#include<vector>
vector<string>   chapter_titles(20);
// 向量～～～标准数组           size=20的数组


$CC -DDEBUG main.c
// 在Unix系统中，命令行中定义预处理器常量   DEBUG 是预处理器常量名字


__cplusplus      //  编译C++时系统自动定义的预处理器名
#ifdef __cplusplus
// 不错，我们要编译c++
extern "C"
#endif
int min(int,int)
_STDC_  //  编译标准C时，编译器自动定义的名字
if(element_count==0)
cerr<<"Eerror:"<<_FILE_    //记录文件已经被
    <<":line"<<_LINE_      //编译的文件名和行数
　　<<"element_count must be non-zero.\n";

_TIME_  //  被编译的时间
_DATE_  //  被编译的日期

#include<assert.h>          //　是C库头文件
assert(filename!=0);        //  是为要使用assert()

// assert() 是C语言标准库中提供的一个通用预处理器宏，
// 用来判断一个必需的前提条件，以便程序能够正确执行

#include<cassert>
// C++中引用C库头文件，以'C'开头

#include<fstream>
#include<iostream>
#inculde<string>
int main()
{ofstream outfile("out_file");
 ifstream infile("in_file");
 if(!infile){
 cerr<<"error:unable to open input file![n";
 return -1;}
 if(!outfile){
 cerr<<"error:unable to open outpur file!\n";
 return -2;}
 string word;
 while(infile>>word)
     outfile<<word<<'';
 return 0;
}
 

int *pint=new int(1024);  //　动态分配指针对象初始值为1024
int *pia=new int[4];      //  动态分配数组
delete pint;
delete[] pia;
 

内联函数在它的调用点上被展开。一般来说，内联函数不会引入任何函数调用，从而节省了函数调用所花费的开销

在类定义中，被定义的成员函数[如size()]会被自动当作是内联函数


class IntArray{
   publec:
int size() const {return _size;}
   private:
        int _size;
        int *ia;
};
for(int index=0; index<array.size();++index)
//　并没有调用size() _size次，而是array.size()的内联扩展成如下
for(int index=0; index<array._size;++index)


\f  进纸键　　\a 响铃符 \v 　垂直制表符



L'a'
//字符文字前加"L"称为宽字符，wchar_t类型


L"a wide string litem1"
//宽字符中类型


"two" "some"   //输出"twosome"
//若两个字符串或宽字符串在程序中相邻，C++ 就会把它们连接
//在一起，并在最后加上一个空字符


int *pi=0;
double dval;
double *pd=&dval;
pi=pd; //错误
pi=&dval; //错误
　　　　　　　　 //虽然没有语法错误，只因是不同的数据类型，编译器对pi和pd的内存布局和内容的解释不同

void *pv=pi; //pv是空(viod*)类型指针，
   pv=pd; //可以持有任何指针类型的地址值
// void* 表明相关的值是个地址，其对象的类型不知道
//我们不能够操纵空类型指针所指向的对象，
//只能传送该地址值或和其它地址值作比较。



int strlen(const char*);
int strcmp(const char*,const char *);
char* strcpy(char*,const char*);
//C风格字符串存储在字符数组中，通过char*类型指针来操纵

71 个解决方案

#1

有空再看看

#2

mark

#3

mark

#4

ｇｏ　ｏｎ

#5

mark

#6

努力学习

#7

不错 ～
MARK ！！

#8

up

#9

虽然内容比较基础，
但是这样大家共享的想法值得发扬 ！！

#10

up

#11

int errNumb = 0;
int *const curErr = &errNumb;
//  curErr是一个指向int类型对象的const指针，
//不能赋给curErr其他的地址值，但是可以修改curErr指向的值。



const double pi = 3.14159;
const double *const pi_ptr = &pi;
//pi_ptr是指向被定义为const的double类型对象的const指针，
//它指向的对象的值以及它的地址本身都不能改变



int ival = 1024;
int &refval = ival;//ok
int &refval2;//错误，引用必须被初始化为指向一个对象。




int min_val = 0;
refval = min_val; //错误！
//ival被设置为min_val的值，refval并没有引用到min_val上。


int li = refval; // 把与ival相关联的值赋给li


int *pi = &refval;//用ival的地址初始化pi

//const 引用可以用不同类型的对象初始化（只要能从一种类型
//转换到另一种类型即可），也可以是如文字常量不可寻址的值。
//例如：
double dval = 3.14159;               //仅对const引用合法
const int &ir = 1024;                //仅对const引用合法
const int &ir2 = dval;               //仅对const引用合法
const double &dr = dval + 1.0;       //仅对const引用合法


//若有:

double dval = 1024;
const int &ri = dval;
//编译器将其转换成:

int temp = dval;
const int &ri = temp;
//如果我们给ri赋一个新值，不改变dval,而是temp。
//不可寻址的值，如文字常量，以及不同类型的对象，
//编译器必须生成一个临时对象

#12

const int ival = 1024;
int *&pi_ref = &ival;   //错误:要求一个const 引用


const int ival = 1024;
const int *&pi_ref = &ival;//错误:
//因为pi_ref是一个引用，它指向定义为const的int型对象
//的一个指针。我们的引用不是指向一个常量，而是
//指向一个非常量指针，指针又指向一个const对象。



const int ival = 1024;
const int *const &pi_ref = &ival;   //ok
//指针和引用的区别是：引用必须总是指向一个对象

#13

学习

#14

这差不多都是《C++ Primer》书上的东西。

#15

LZ做笔记的风格很好啊  值得学习
找准关键下手，废话几乎没有
MARK！
坚持发下去  偶坚持顶下去

#16

mark

#17

晕，就是C++ primer上抄下来的

#18

天书啊，看不懂，我一新手，呵呵

#19

vector<int> ivec(10,-1);
//定义的ivec向量含有初值为-1的10个元素

vector<int> civec(ivec);
//将向量ivec赋值给向量civec


#include<complex>    //复数类的头文件
complex<double>   pure(0,7)  //0是实数，7是虚数



typedef char* cstring;
extern const cstring cstr;//它的类型是？

const char *cstr;//错误
char *const cstr;//对了

//const修饰cstr的类型，cstr是一个指针，
//因此，这个定义声明了cstr是一个指向字符const指针


//当一个对象的值可能会在编译器的控制或监测之外被改变时，
//例如一个被系统时钟更新的变量，那么该对象应该声明成volatile。
//因此，编译器气质的某些例行优化行为不能应用在已指定为volatile的对象上。
volatile  int display_register;
volatile  Task *curr_task;
volatile  int ixa[max_size];
volatile  Screen   bitmap_buf;




#include<utility>   //为了使用pair类
pair<string,string> author("James","Joyce");
if(author.first == "James" && author.second == "Joyce")
   firstBook = "Stephen Hero";
//pair类使得我们可以在单个对象内部把相同类型或不同类型的两个值关联起来。


//复数操作
#include<complex>
complex<double> complex_obj = a + 3.14159;
double re = complex_obj.real();  //取实部
double im = complex_obj.imag();  //取虚部
//等价于：
double re = real(complex_obj);
double im = imag(complex_obj);


//sizeof操作符有三种类型：
sizeof (type name);
sizeof (object);
sizeof object;

#include<cstddef>    //要使用sizeof
int ia[]={0,1,2};
size_t array_size = sizeof ia;  //返回整个数组大小
//size_t是sizeof的返回类型

size_t element_size = array_size/sizeof(int);  //返回int 类型的大小


int *pi = new int[3];
size_t pointer_seze = sizeof(pi);
//sizeof(pi)返回的值是指向int型的指针的字节长度，
//而不是pi指向的数组的长度

#20

多谢楼主

#21

多谢

#22

UNIX系统？
ｕｐ

#23

呵呵,多谢,,学习,希望   更多共享!

#24

没看出楼主对这段程序有哪些自己的想法或见解, 有哪些扩展性的思想, 仅仅是对源程序的注释的话, 那这种读书笔记的要求层次还是太低了点.

#25

谢谢你们啊，我是C++初学者，
我浏览了一遍C++ Primer　，现在在复习笔记，请问看完C++　Primer后，我可以看什么书，可以使自己的C++水平有更大的提高呢？

#26

~  <<  >>  &  ^  |   &=    ^=    |=

unsigned int quiz1 = 0;
//在大多数情况下，符号位的理是未定义的，强烈建议使用无符号类型
1<<27;
quizl |= 1<<27;//=>quizl 1 = (1<<27);


inline  bool bit_on(unsigned int ui,int pos)
{return ui&(q<<pos);}
//位操作符在较低的层次上操纵，易错，所以，
//它们被封装在预处理器宏或内联函数中。


#include<bitset>   //位操作
test(pos)       q.test(4)       第４位是否为１？
any()           a.any()         任意位是否为１？
　 a.nne() 是否设有位为１？
a.count() 值为１的个数。
a.size()  位元素的个数。
a[4] 访问pos位。
a.flip() 翻转所有位。
a.set() 将所有位置１。
a.reset()
a.reset(4)


quizl |= 1<<27;  //可写成
quizl[27] = 1;

或:quizl.set(27);


bitset<32>  bitvec;   //bitset 类的声明，32位长
　　　//默认秘有位0;

bool  is_set = bitvec.any();//测试含1位有没？


for (int index = 0;index<32;++index)
    if(index % 2 == 0)
       bitvec[index] = 1;
//将偶数位设为1.




bitvec.flip(0);//翻转第一位
bitvec[0).flip();//也是


bitvec.flip();//翻转所有位。




bitset<32> bitvec2(0xffff);//低16位设为1.
bitset<32> bitvec3(012);// 第1、3位设为1。


string bitval("1111110101100011010101");
bitset<32> bitvec5(bitval,6,4);
//从位置6开始，长度为4:1010;1、3位置为1，其它0;

bitset<32>  bitvec6(bitval,6)
//从位置6开始，一直到串尾置为1.

string  bitval(bitvec3.to_sting());
//将bitset对象=>string表示

unsigned long bitval(bitvec3.to_ulong());
//将bitset对象=>unsigned long 型整数表示

#27

我开始学做笔记，一个字，抄出或提炼出书中实质性的东西，能抄则抄，不能抄也尽可能的采用原话，书中实在罗嗦，那就自己提炼，哈哈，相当于做个存档

楼主比我用心多了，ＭＡＲＫ

#28

很长时间没有看过C++了，看了搂住的笔记，觉得还是比较不错的！

#29

这种贴还能不顶么？

#30

ruyitao(记忆不陌生) ( ) 信誉：100  2006-4-8 19:22:12  得分: 0  
 
 
   
谢谢你们啊，我是C++初学者，
我浏览了一遍C++ Primer　，现在在复习笔记，请问看完C++　Primer后，我可以看什么书，可以使自己的C++水平有更大的提高呢？

  
 
你又吹牛了不是。。。。。。

#31

lz好热心哦，这种共享的精神值得发扬。
顶！

#32

int ival;
int *pi = 0;
char *pc = 0;
void *pv;

pv = pi;//ok,隐式转换
pv = pc;//ok,隐式转换

const int *pci = &ival;
pv = pci;//错误:pv不是const void*
const void *pcv = pci;//ok

//任何非const数据类型的指针都可以被赋值给
//void* 型指针

#include<cstring>
int ival = 1024;
void *pv;
int *pi = &ival;
const char *pc = "a casting call";
void mumble()
{
  pv = pi; //ok:pv指向ival
  pc = pv; //错误:没有标准的转换
　　　　　 //pv 指向一个整数而不是一个字符数组　　　
  char *pstr = new char[strlen(pc) + 1];
  strcpy(pstr,pc);
}

void mumble()
{pc = static_cast<char*>(pv);
 char *pstr = new char[strlen(pc) + 1];
 strcpy(pstr,pc);
}


//const_cast 转换掉表达式的常量性(以及volatile对象的volatile性)。例如:
extern char *string_copy(char*);
const char *pc_str;
char *pc = string_copy(const_cast<char*>(pc_str));

enum mumble{first = 1,second,third};
extern int ival;
mumble mums_the_word = static_cast<mumble>(ival);
//只有当ival含有值1，2或3的时候，转换才正确


complex<double> *pcom;
char *pc = reinterpret_cast<char*>(pcom);
string str(pc);//错误:运行时未定义。
//reinterpret_cast 通常对于操作数的位模式
//执行一个比较低层次的重新解释。
//此例说明了显示强制转化的危显性


if(ptr){
  if(*ptr == "quit")
   break;     //错误！
   }
//一般说来，break语句只能出现在循环或
//switch语句中。


continue 语句:
continue语句只出现在循环语句中才是合法的。

//goto语句
int ok_its_fixed()
{
  goto end;
  {
    //ok:在语句块中声明语句
　　int ix = 10;
    //......code using ix
  }
 end:;
}
//goto语句向前跳过的语句必须是单独的语句块，因构造函数故。
//向后跳，则没有此规定。

//如end:标签，用在goto中，以冒号结束，
//但是，不直接放在}前面，要这样end:;}才是对的。

#include<vector>
#include<iostream>
int main()
{
  vector<int> ivec;
  cout << "ivec:size:" << ivec.size()
      << "eapacity:" << ivec.capacity() << endl;  
for(int ix = 0; ix < 24;++ix){
  ivec.push_back(ix);
  cout << "ivec:size:" << ivec.size()
       << "capacity:"  << ivec.capacity() << end;
  }
}
//capacity容量:容器下一次需要增长自己之前能够被加入到容器中的元素的总数
//(只与边疆存储的容器相关:例如vector、deque或string。list 不需要容量)
//长度:容器当前拥有元素的个数

#33

//顺序容器:list  vector  deque
//关联容器:map(映射)　set(集合)
vector<string> svec;
list<int> ilist;
//容器对像的定义以容器类型的名字开始。



int ia[4] = {0,1,2,3};
for (int ix = 0; ix<4; ++ix)
  ilist.push_back(ia[ix]);
  //将元素插在容器的尾部


for (int ix = 0;ix < 4; ++ix)
ilist.push_front(ia[x]);
//将元素插入在容器的前端


svec.resize(2*svec.size());
//重新设置容器的长度


svec.resiae(2*svec.size(),"piglet");
//将每个新元素初始化为piglet




#include<vector>
#include<string>
#include<iterator>
int main()
{
  istream_iterator<string> infile(cin);
  //将输入绑定到标准输入上
  istream_iterator<string> eos;
  //标记流结束位置的输入流iterator
  vector<string> svec(infile,eos);
  //利用通过cin输入的初始化svec
}


vector<string> svec;
list<string> slist;
string spouse("Beth");
slist.insert(slist.begin(),spouse);
slist.insert(svec.begin(),spouse);
//插入在位置的前面


string son("Danny");
list<string>::iterator iter;
iter = find(slist.begin(),slist.end(),son); //返回被查找元素在容器中的位置
slist.insert(iter,spouse);
　
slist.push_back(value);//等价于:
slist.insert(slist.end(),value);

vector<string> svec;
string anna("Anna");
svec.insert(svec.begin(),10,anna);
//在开始处插入10个"Anna"


string sarray[4] = {"quasi","simba","frollo","scar"};
svec.insert(svec.begin(),sarray,sarray+4);
//插入全部
svec.insert(svec.begin()+sarray.size/2,sarray+2,sarry+4);


svec_two.insert(svec_two.begin()+svec_two.size()/2,svec.begin(),svec.end());
//从svec_two的中间开始插入svec。

#34

study

#35

我没记过笔记，如果看了以后书比较好就找个电子版扔那，随时查：）

#36

支持一下

#37

string searchValue("Quasimodo");
list<string>::iterator iter = find(slist.begin(),slist.end(),searchValue);
//找到要删除元素的位置
if(iter != slist.end())
   slist.erase(iter);　//删除元素的方法


slist.erase(slist.begin(),slist.end());
//删除容器中的所有的元素

list<string>::iterator fist last;
fist = find (slist.begin(),slist.end(),val1);
last = find (slist.begin(),slist.end(),val2);
slist.erase(first,last);
//删除由iterator标记的一般范围内的元素


vector<string>::iterator iter = buffer.begin();
for(;iter != buffer.end();iter++)
  {slist.push_back(*iter);
   if(!do_something(slist))
   slist.pop_back();
}
 
slist1.swap(slist2);//对换方法

//获得文本的每一行，标准库支持getline()函数；
istream&
getline(istream &is,string str,char delimiter);

//find()返回string::npos  表明没有匹配

//如int pos = name.find("Anna");虽然可以，但是更严格、可移植的正确声明应该使用以下形式:
string::size_type pos = name.find("Anna");

find_first_of()
//查找与被搜索字符串任意一个字符相匹配的第一次出现，并返回它的索引位。

find_last_of()
//与上面的相反

#38

string river ("Mississipppi");
string::size_type first_pos = river.find("is");
string::size_type last_pos = river.rfind("is");//返回最右边的is

string elems("0123456789");
string dept_code("0371493);
string::size_type pos = dept_code.find_first_not_of(elems);
//查找第一个不与要搜索字符串的任意字符相匹配的字符
//find_last_not_of()的作用相反


//在不支持缺省模板参数值的编译器下被编译的，必显式提供一个分配器(allocator)
vector<string,allocator> *lines_of_text;

//在完全支持标准C++的编译器下面，我们只需要指定元素的类型
vector<string> *lines_of_text;


#include<ctype.h>
//要使用isalpha(),tolower(),toupper(),isdigit(),ispunct(),isspace(),.....


//在C++中，要包含头文件
#include<locale>
string::size_type pos3 = word.size()-3;
string ies("ies");
if(!word.compare(pos3,3,ies))//开始位置，长度，比较串
{
 word.replace(pos3,3,1,'y');//开始位置，长度，长度，替换字符
 return;
}


string::size_type spos = ;
string::size_type spos3 = word.size() - 3;
string suffixes("oussisius");
if(!word,compare(pos3,3,suffixes,spos,3);
return;

typedef stirng::size_type size_type;
size_type startpos = name.find('L');
size_type endPos = name.find_last_of('a');
name.erase(name.begin() + startpos,name.begin + endPos);

insert(position,new_stirng);


string s1("Mississippi");
string s2("Annabelle");
s3.assign(s1,0,4); //拷贝前4个
s3+='';
s3.append(s2,0,4);
//等价于:
s3.assign(s1,0,4).append('').qppend(s2,0,4);
//结果是:"Miss Anna"



#include<map>
map<string,int> word_count;
//string是索引，int是值

typedef pair<short,short> location;
typedef vector<location> loc;
map<string,loc*> text_map;
map<stirng,loc*,  //键值对
　　less<string>,  //用作排序的关系操作符
　　allocator>    //缺省的内存分配操作符
　　text_map;

//at()操作提供了运行时刻对索引值的范围检查　
void
mumble(const string &st,int index)
{
  try{
    char ch = st.at(index);
     //.......
    }
  catch(std::out_of_range){......}
    //......
}

#include<map>
#include<string>
map<string,int> word_count;
word_count[string("Anna")] = 1;
word_count[string("Danny"] = 1;
word_count[string("Beth")] = 1;
 

word_cont.insert(map<string,int>::value_type(string("Anna"),1));
//创建一个pair对象，将直接插入map


typedef map<string,int>::value_type valType;
word_count.insert(valType(string("Anna"),1);

#39

xiang dajia xuexi

#40

up

#41

我看不懂，水平还是不行啊，要多顶高手们学习。

#42

MARK!

#43

学习中～～～

#44

学习~

#45

map<string,int> word_count;
map<string,int> word_count_two;
word_count_two.insert(word_count.begin(),word_count.end());
map<string,int> word_count_two(word_count);


typdef pair<shor,short> location;
typedef  vector<location> loc;
typedef vector<string> text;
typedef pair<text*,loc*> text_loc;
extern map<string,loc*> *build_word_map(const text_loc *text_location);
map<string,loc*> *world_map = new map<string,loc*>;
vector<string> *text_words = text_location -> first;   //从作为参数的pair
vector<location> *text_locs = text_location -> second; //对象中分离出字符串和位置vector


//map<string,int> word_count;
int count = word_count["wrinkles"]
//如果word_count中不正在，引起插入一个实例，键值对：string ("wrinkles"),0

int count = 0;
if ( word_count.count("wrinkles"))//判断存在否，若否，也不会插入实例
    count = word_count("wrinklis");


int count = 0;
map<stirng,int>::iterator it = word_count.find("wrinkles");//返回指向实例的iterator
if(it!=word_count.end())
 count = (*it).second;

//从map中删除元素
string removal_word;
cout<<"type in word to remove:";
cin>>removal_word;
if(text_map -> erase(removal_word))
cout<<"ok:"<<removal_word<<"removed\n"
else cout<<"ops:"<<removal_word<<"not found!\n";

map<string,loc*>::iterator where;
where = text_map.find(removal_word);
if(where == text_map -> end())
  cout<<"oops:"<<removal_word<<"not found!\n";
else{
  text_map->erase(where);
cout<<"ok:"<<removal_word<<"removed!\n";
}


#include<set>
set<string> exclusion_set;
exclusion_set.insert("the");
exclusion_set.insert("and");

//multimap 和 multiset 允许要被存储的键出现多次
#include<map>
#include<set>
multimap<key_type,value_type> multimapname;
//按string索引，存有list<stirng>
multimap<string,list<string>>synonyms;
multiset<type> mutisetname;


#include<map>
#include<string>
void code_fragment()
{
  multimap<string,string> authors;
  string search_item("Alain de Botton"):
int mumber = authors.count(search_item);
multimap<string,string>::iterator iter;
iter = authors.find(search_item);
for(int cnt = 0;cnt<number;++cnt,++iter)
 do_something(*iter);
}

#include<map>
#include<string>
#include<utility>
void code_fragment()
{
 multimap<string,string> authors;
 string search_item("Harccki Murakam!");
 while(cin &&cin>>search_item))
 switch(authors.count(search_item))
{
 case 0:break;
case 1:{
   multimap<string,string>::iterator iter;
   iter = authors.find(search_item);
   break;
      }
default:
{
 typedef mutimap<string,string>::iterator iterator;
 pair<iterator,iterator> pos;
 //pos.first指向第一个出现
　//pos.second 指向值不再出现的位置
pos = authors.equal_range(search_item);
for(;pos.first != pos.second;pos.first++)
  }
 }
}

//multimap 不支持下标操作

#46

还是不大明白map和set！

#47

好贴

#48

虽然现在还看不懂多少，但是收藏起来！

#49

顶.但是看不懂

#50

void swap(int v1,int v2){
int tmp = v2;
v2 = v1;
v1 = tmp;
 }
#incude<iostream>
void swap(int,int);
int main(){
int i = 10,j = 20;
cout<<"Before swap():\ti:"<<i<<"\tj:"<<j<<endl;
swap(i,j);
cout<<"After swap():\ti:"<<i<<"\tj:"<<j<<endl;
return 0;
}
//结果：
//before swap():i:10 j:20
//After swap():i:10  j:20
//按值传递时，函数不会访问当前调用的实参，函数
//处理的值是它本地的考贝。


//参数被声明成指针可以修改实参,如:
void pswap(int *v1,int *v2){
 int tmp = *v2;
 *v2 = *v1;
*v1 = tmp;
}
//...
pswap(&i,&j);
//...
//现在传递　给参数的是地址，而不是对象本身


//2.把参数和声明成引用。
void rswap(int &v1,int &v2){
 int tmp = v2;
 v2 = v1;
 v1 = tmp;
}
//...
rswap(i,j);
//...


void ptrswap(int *&v1,int *&v2){
int *tmp = v2;
 v2 = v1;
 v1 = tmp;
}
//右->左读：v1是一个引用，它引用一个指针，指针指向int型的对象。
#include<iostream>
void ptrswap(int *&v1,int *&v2);
int main(){
 int i = 10;
int j = 20;
int *pi = &i;
int *pj = &j;
cout << "Before ptrswap():\tpi:"
     << *pi<<"\tpj:"<<*pj<<endl;
ptrswap(pi,pj);
cout<<"After ptrswap():\tpi:"
    <<*pi<<"\tpj:"<<*pj<<endl;
 return 0;
}
//程序员想修改指针本身，而不是指针引用的对象。


class Type{};
void operate(const Type& p1,const Type& p2);
int main(){
Type obj1;
//设置obj1为某个值
//错误：引用参数的实参不能为0
Type obj2 = operate(obj1,0);
}

//如下声明：
void putValues(int[10]);
//被编译器视为：
void putValues(int *);
//因此：void putValues(int[]);等价于以上两个。

//缺省实参：
char *screenInit(int height = 24,int width = 80,char background = '');

//下面是调用
char *cursor;
//等价于screenInit(24,80,'')
cursor = screenInit(0;
//等价于screenInit(66,80,'')
cursor = screenInit(66);

//函数调用的实参按位置解析，缺省实参只能用来替换函数调用缺少的尾部实参
//错误：不等价于screenInit(24,80,'?')
cursor = screenInit(,,'?');


//在左边参数的任何缺省实参被提供之前，最右边未初始化参数必须被提供缺省实参。
//错误：在指定height之前，width必须有一个缺省实参。
char *screenInit(int height  = 24,int width,char background = '');


void foo(parm_list,...);
void foo(...)
//告知编译器，当函数调用时，可以有0个或多个实参

//标准c库函数printf():
int printf(const char*,...);
//若有：
printf("Hello,word\n");
//有一个字符串实参：
printf("Hello,%s\n",userName);
//%说明需要第二个实参

//链接指示符：extern "c"
//单一语句开工的链接指示符：
extern "c" void exit(int);
//复合语句形式的连接指示符
extern "c" {
 int printf(const char*,...);
 int scanf(const char *,...);
}

//复合语句形式的链接指示符
extern "c"{
 #include<cmath>;
}

int main()
{
 //错误：链接指示符不能出现在函数内
　exter "c" double sqrt(double);
  double result = sqrt(getValue());
//...
return 0;
}

//如果把链接指示符移到函数体外，程序编译将无错误：
extern "c"double sqrt(double);
int main()
{
  double getValue();
  double result = sqrt (getValue());
 //...
return 0;
}