#1:C++:初步知识;

2018-01-22 10:42:45来源:网络收集作者:程序诗人人点击

分享

[var1]

                                                                   C++ 的初步认识:

1. 在 C++ 中 一般在主函数 main 前面用 int来定义,表示返回值为整形,
    如果程序正常执行,这返回值为 0; 否则返回值为非零,一般为-1;
 
2. 在 C++ 中,一般使用 cout , cin 表示输出和输入;    对于 cout 表示 c 和 out 的组合,表示输出流对象, << 为插入运算符,与 cout 配合使用;
    
    本例中的作用是把 双引号 内的字符串插入到输出的队列 cout 中。
    
    除此之外也还可以用 printf  输出;
    
3. 在 C++ 中,通常不在头文件引用中加入 .h ,而用户自己编译的头文件中可以加.h;    例如: #include
      
4.    using namespace std; 表示使用命名空间 std , C++ 中的标准类和库函数都是在 std 里边命名的;
 
例:输出一行话


int main()
{
cout << "This is a C program. " << endl;
return 0;
}
例:流输入,流输出:int main()
{
int a,b,sum;cin >> a >> b;
sum = a + b;cout << "a + b =" << sum << endl;
return 0;}
说明:

1 . cin 表示 c 和 in 的组合, cin 是输入流对象; >> 是提取运算符,与cin配合使用;
    表示从输入设备中提取数据到输入流 cin 中;
    
2. endl 是 c++ 的输出时的控制符,作用是换行( end line 的缩写 ),表示本行结束,与/n 作用类似;注: 输入中间只可用空格, 若用逗号或别的分隔符,则出错;
        若要输入空格符,需要用别的函数;


例:比大小:


int main()
{
int max(int a,int b);
int x,y,z;cin >> x >> y;
z = max(x,y);cout << "max = " << z << endl;return 0;
}
int max(int a,int b)
{
int z;
if( a < b)
{
z = b;
}
else
{
z = a;
} return z;
}
面向对象设计时的例子:class Student// 声明一个类,类名为 Student
{
private://类中的私有部分:
int num;//私有变量 num
int score;//私有变量 score public://类中的公用部分;
void setdata() //公用函数 setdata
{
cin >> num;//输入 num;
cin >> score;//输入 score;
}
void display()//公用函数 display
{
cout << "num = " << num << endl;
cout << "score = " << score << endl;
}
};//类的声明结束;
Student stu1,stu2;//定义两个 Student 类型的变量,称为对象;
int main()
{
stu1.setdata();
stu2.setdata();
stu1.display();
stu2.display();

return 0;
}
说明:

      class 为类 类型的声明,可以包含 数据 和 函数,称为 数据成员 和 成员函数;类中的数据和函数分为两大类: 公有的 public ,私有的 private:对于被指定公有的数据和函数,即可以被本类成员中的成员函数调用,也可以被类外的语句调用;对于被指定私有的数据和函数,只能被本类中的成员函数所调用,不能被类外调用( 友元类除外 );      这样可以用来保护数据,只有本类中的成员函数可以调用,防止误调;
    
对于 class 本身作为一个类型,是不占用实际的存储空间,但是一旦 class 定义了一个 对象,则占用实际空间;当类外调用成员函数的时候,必须要说明要调用哪个对象的函数,采用 . 成员运算符;

                                                        C++ 中的 输入和输出:



    1. 采用 cout 输出:
        
        cout 必须和  << 一起使用, 在这里 << 被重载为 插入,而不是 左移的运算符;
        
        可以在一个输出语句中使用多个 << 运算符 将多个输出项插入到输出流 cout 中;
        
        << 运算符的结合方向为 自左向右, 输出项也是自左向右顺序插入到输出流中;


例:


int main()
{
for(int i = 0; i < 3;i++)
{
cout << "count = " << i << endl;
}
return 0;
}
注 :   1. 每一个输出都要单独用一个 << ;
           2. 输出时可以不用指定数据类型,而系统会自动按数据类型进行输出,这比 printf 要方便;
           3. 如果要指出输出所占的列数,可以用 setw ( iomanip.h头文件 );

例:使用 setw()输出:


int main()
{
int a = 5;
float b = 2.12;
double c = 3.1415;cout << "a = " << setw(6) << a << endl << "b = " << setw(6) << b << endl;
cout << "c = " << setw(6) << c << endl;return 0;
}
setw() 表示 为其后面一个输出项 预留五列, 若输出不足五列,则右对齐,若超过五列,按原长度输出;

    2. 采用 cin 输出:
    
     输入流 指 从输入设备 向内存中流动的数据流, >> 把数据送到内存; 称为 提取extracting 或 得到 getting
 


例:


int main()
{
cout << "Please enter your name and age: " << endl;
char name[10];
int age;
cin >> name;
cin >> age;
cout << "Your name is : " << name << endl;
cout << "Your age is : " << age << endl;return 0;
}

                                                        Const 定义常量:



    在C语言中 经常使用 #define 来定义符号常量 #define PI 3.1415, 这样很容易出错;
    所以C++ 中采用了 const 类型来定义常变量:


例:


int main()
{
const float PI = 3.1415;cout << PI << endl;//PI = 3.15;return 0;
}
    在程序运行期间,此变量的值是固定的不可改变,但是是作为一个值不可改变的变量处理;

                                                        函数:


      1. 函数的原型声明:


           在 C++ 中 必须对函数的返回值类型进行声明 ( C 中若返回值为 int可以省略 ) ;
          但是可以参数表中可以只包含参数类型,而省略参数参数名:


例:


int main()
{
int x,y,m;
cin >> x >> y;
int max(int ,int );m = max(x,y);
cout << m << endl;
return 0;
}int max(int a, int b)
{
if( a < b) return b;
else return a;
}
       2. 函数的重载:           对于前面出现的 插入 和 提取符 : << ,>>; 本来是左移和右移 但是C++ 中又作为别的运算符,
           即允许一个运算符符合不同的场合,称为重载overloading;
例:

    在 C 中 若完成一个求取 3个数中的最大数,在类型未知时需要分别写:

int max1(int ,int );
float max2(float ,float);
long max3(long ,long );

    而C++ 中允许在同一个作用域之下,用同一个函数名定义多个函数,但这些函数的参数和类型必须有所不同;
    这些同名的函数用来实现不同的功能,即重载; 参数类型不同:


int main()
{
int q,w,e;
float a,s,d;
long z,x,c;int max(int a,int b,int c);
long max(long a,long b,long c);
float max(float a,float b,float c);
cin >> q >> w >> e;
cout << max(q,w,e) << endl;cin >> a >> s >> d;
cout << max(a,s,d) << endl;cin >> z >> x >> c;
cout << max(z,x,c) << endl;return 0;
}
int max(int a,int b,int c)
{
if( b > a)
{
a = b;
}
if( c > a)
{
a = c;
}
return a;
}
long max(long a,long b,long c)
{
if( b > a)
{
a = b;
}
if( c > a)
{
a = c;
}
return a;
}
float max(float a,float b,float c)
{
if( b > a)
{
a = b;
}
if( c > a)
{
a = c;
}
return a;
}

参数个数不同:


int main()
{
int a,b,c;
int max(int ,int ,int );
int max(int ,int );cin >> a >> b >> c;
cout << max(a,b) << endl;
cout << max(a,b,c) << endl;
return 0;
}
int max(int a,int b,int c)
{
if( b > a)
{
a = b;
}
if( c > a)
{
a = c;
}
return a;
}
int max(int a,int b)
{
if( a>b )
{
return a;
}
else
{
return b;
}
}
    系统会自动根据参数的个数找到与之匹配的函数并调用;
    不允许参数个数与类型相同,仅返回值不同!

                                                        3.
函数的模板:    即建立一个通用函数,其函数类型和形参类型不具体指定,用一个虚拟的类型来代替;
    则不必定义多个函数,在调用时系统会根据实参的类型来代替模板中的数据类型;


template//注: 后无分号!!!!
T max(T a,T b,T c)
{
if( b > a)
{
a = b;
}
if( c > a)
{
a = c;
}
return a;
}
int main()
{
int q,w,e;
float a,s,d;
long z,x,c;
cin >> q >> w >> e;
cout << max(q,w,e) << endl;cin >> a >> s >> d;
cout << max(a,s,d) << endl;cin >> z >> x >> c;
cout << max(z,x,c) << endl;return 0;
}

    template 的意思是模板,尖括号中 写 typename XXX, 表示一个虚拟的类型名;
    要等到函数调用时才知道 T是什么类型; 类型函数也可以不止一个 : template< typename T, typename TT >;     但它只适用于函数的参数个数相同,而类型不同的情况;参数个数不同时不可使用;


                                                        4.
有默认参数的函数:



    有时需要调用同一个函数时用的都是同一个实参值,此时可以给形参一个默认值;
如:
    float area( float r = 6.5 );
    
则指定 r 的默认值为 6.5 此时调用时可以不必给出实参值:    area(); 或者给出别的实参值:    area(3.5); 若有多个形参,可以使每一个参数都有默认值,也可以只对一部分形参指定默认值,另一部分不指定; 如:
    float volume( float h, float r = 16.5 )    //    仅仅指定 r的默认值; 可以引用为:
    volume(100);
    volume(100,15);  
 
实参和形参的结合是从左至右的,因此,指定默认值的参数必须放在形参列表的最右端:如:
    void f1( int a, int b = 5, int c );     //    错误;
    void f2( int a, int b, int c = 5 );        //    正确; 注意:
1.
如果函数的定义在函数的调用之前,则应在函数定义中给出默认值;
如果定义在调用之后,则必须在声明中给出默认值,定义中可以不给出;2.
一个函数不能既作为重载函数,又作为有默认参数的函数,否则在调用时可能分不清;


                                                        变量的引用
:reference



    变量的引用又称为别名 alias,即为变量起另外一个名字,需要时可以方便、间接的引用;
如:
    int a;
    int    &b = a;     //    & 不代表取地址;
这就声明了 b 是 a 的引用,即别名。    此后 a和 b表示同一个变量;
在引用时只有声明,没有定义,不单独分配空间,只声明它和原有变量的关系;在声明一个变量的引用后,在本函数的执行期间,该引用不能再作为其他变量的别名;
如:
    int a1,a2;
    int &b = a1;
    int &b = a2;    //    错误; 1. 引用的简单使用:


int main()
{
int x;
int &a = x;cin >> x;cout << a << endl;a = a*a;//当 X的值变化时,a的值也发生变化;
cout << a << setw(5) << x << endl;x = x/2;cout << a << setw(5) <} 关于引用的说明:    1. 引用不是一个单独的数据类型,必须与另外的一个数据联系;声明的同时必须进行初始化;
如:
    int &b = a;            //    正确
    int &b;                //    错
    float a;int &b = a;    //     错      2. 引用和其所指带的变量共享同一个内存空间,而系统不为引用另外分配空间;int main()
{
int a = 3;
int &b = a;
cout << &a << " " << &b << endl;
return 0;
}
     3. 同一个变量可以有多个不同的别名:
如:
    int a = 3;
    int &b = a;    //    a 的别名;
    int &c = b; //    c 为 b 的别名,即 a的第二个别名;     4. 一个引用在初始化后,不可被重新声明为另一个变量的别名;2. 将引用作为函数参数:
    
    对于C语言中,函数传值有两种情况:
      1. 将变量名作为实参:
          此时传递是单向的,形参值的变化,并不回传给实参,所以实参的值不发生变化;
          因为在函数执行时,形参和实参不是同一个存储单元; void swap(int a,int b)
{
int temp;
temp = a;
a = b;
b = temp;
}
int main()
{
int i,j;cin >> i >> j;
swap(i,j);
cout << i << ',' << j << endl;
return 0;
}

程序执行结束后,取值并不发生变化;       2. 传递变量的指针:
          使形参得到一个变量地址,这时形参指针变量指向实参变量单元。


void swap(int *x,int *y)
{
int *temp;
temp = x;
x = y;
y = temp;
}
int main()
{
int i,j;cin >> i >> j;
swap(i,j);
cout << i << ',' << j << endl; return 0;
}
      3. 传送变量的别名:
          把变量的引用作为形参;void swap(int &a,int &b)
{
int temp;
temp = a;
a = b;
b = temp;
}
int main()
{
int i,j;cin >> i >> j;
swap(i,j);
cout << i << ',' << j << endl;

return 0;
}
  在 swap 的函数列表声明中 a 和 b 是整形变量的声明;( 注: 此处的 &a不是地址,而是引用  )
  而引用型形参的初始化是在函数调用时,通过虚实结合实现的:
    当调用 swap 时,由实参将变量名传给形参,
    实际上实参传给形参的是地址,从而使两个变量拥有相同的地址;

关于引用的进一步说明:1. 不能建立 void 型的引用; 2. 不能建立引用的数组:
如:
    char c[6] = "hello";
    char &cp[6] = c; 3. 可以将变量的引用的地址赋给指针,此时指针指向的是原来的变量:    int a = 3;
    int &b = a;
    int *p = &b;    //    p 指向 b 的地址,即 a的地址; 4. 不能定义指向引用类型的指针变量,但是可以建立指针变量的引用:
如:
    int &*p = &a ;    // cuo;
    
    int i = 5;
    int *p = &i;
    int *&pt = p;    //    pt 是一个指向int 型变量指针的引用,初始化为 p,即 tp = p; 5. 可以用const 对引用加以限定,不允许改变该引用的值;    int  i = 5;
    const int &a = i;
    a = 3;                //    错误;
但是并不阻止改变引用所代表的变量的值:
    i = 3;                //    正确; i = a = 3; 有时希望保护形参的值不被修改; (链表的表头)6. 可以用常量或者常量表达式对引用进行初始化,但此时必须使用 const 做声明;
如:
    int i = 3;
    const &a = i + 3;    //    合法;
    
 此时:编译系统首先定义一个临时变量temp 用来存放该表达式的值:
 
     int temp = i + 3;
    const &a = temp; 临时变量是内部生成的,用户不可访问;
    
这种方法可以用来初始化类型不同的变量的引用声明:
如:
    double d = 3.14159;
    const int &a = d;
此时系统现将 其转化为:
    int temp = d;        //    将double型的d 转化为 int型 的temp;
    const int &a = temp;    
 
但是必须加上const ,如果不加,将失去temp 赋值的一步,出现编译错误;


                                                        内置函数:


    调用函数的时候,需要一定的时间,如果有的函数需要频繁被调用 ,则累计时间可能会很长;
    c++ 提供一种在编译时将所用函数的代码嵌入到主函数中,称为内置函数( 内嵌函数 );只需在函数首行的左端加上关键字 inline 即可;


inline int max(int a, int b)
{
if(a>b)
{
return a;
}
else
{
return b;
}
}
int main()
{
int x,y;cin >> x >> y;cout << max(x,y) << endl;return 0;
}
内置函数和用 #define 定义的带参宏定义有一些相似,但是避免了宏定义可能产生的错误;注:
    使用内置函数可以节省运行时间,但是却增加了目标程序的长度;
    如果要调用10次函数,则编译时将先后10次将代码复制,插入main函数;

                                                        作用域运算符:


float a = 13.5;
int main()
{
int a = 5;cout << a << endl;
cout << ::a << endl;return 0;
}
根据规定,局部变量将屏蔽全局变量,此时可以用 作用域运算符 :: ; 此时 ::a 表示全局变量中的 a;
注:不可采用 :: 访问函数中的局部变量!

                                                        字符串变量:


    C++ 中提供了字符串类型 string 类型来定义字符串变量; ( 实际为一个类 )1. 定义字符串变量:
    
     字符串变量也必须先定义后使用:
如:
    string string1;
    string string2 = "China";
注:
    此时要包含头文件:
     //    不是 !!!! 2. 对字符串变量的赋值:    1. 可以使用赋值语句对string类型的变量进行赋值:
    string1 = "Canada" ;
    
    而使用字符数组的时候是不可以的:
    char str[10];
    str = "Canada";     //    错误; strcyp();     2. 也可以用一个字符串变量给另一个字符串变量赋值:(运算符重构!)
    string2 = string1;
    
    此时不要求两个字符串的长度一致,也不需要指定长度,它的长度随字符串的改变而改变;
    
    3. 可以对字符串变量某一个字符进行操作:
如:
    string word = "Chini";
    word[4] = 'a';    //    对序号为4 的字符进行修改;注:
    字符串常量以'/0'结尾( 在字符数组中也是如此 ),但将字符串常量存放到字符串变量中后,
    只存放字符串本身,而不存放'/0'!!    
3. 对字符串变量的输入输出:    可以在输入输出时采用字符串变量名进行输入输出:
如:
    cin >> string1;
    cout << string2;4. 字符串变量的运算:    1. 赋值运算实现复制:
        string1 = string2;
        
    2. 加法运算实现连接;
        string str1 = "C++";
        string str2 = "Language";
        str1 = str1 + str2;
        
    3. 关系运算符实现比较;
    
    
5. 字符串数组:
    
    也可以用string 定义一个数组:
        string name[5] = { "ZK11111","ZK2222","ZK333","ZK44","ZK5", };
此时:
    1. 一个字符串数组中可包含多个字符串变量;
    
    2. 并不要求每一个元素具有相同的长度;    3. 字符串数组与字符数组存在着本质上的区别;     4. 每一个字符串元素中仅仅包含字符串本身的字符,而不包含"/0";注:
    实际上,编译系统对每一个字符串变量分配的都是固定的字节数,用来存放的是字符串的地址;
    即在字符串变量中存放的是指针;


template
TT max(TT a,TT b,TT c)
{
if(b > a)
{
a = b;
}
if(c > a)
{
a = c;
}
return a;
}
int main()
{
string str1,str2,str3,temp;cout << "Please Input three strings:" << endl;cin >> str1 >> str2 >> str3;cout << max(str1,str2,str3) << endl;return 0;
}

                                                        动态分配和撤销内存运算符:new
和 delete


    在C语言中是运用库函数 malloc 和 free 来分配和撤销内存空间的;
    但是malloc 必须指定开辟空间的大小 : *p = ( type )malloc( sizeof() );
    并且必须在程序中进行强制类型转换;     而在C++ 中增加了new ,delete 来代替:
如:
    new int;
    new int(100);
    new char[10];    float *p = new float(3.14159)    //    开辟一个存放实数的空间,并指定初值为3.14159;    1. new 运算符的一般格式为:
    
        new 类型(初值);并返回对应的指针类型;
        
     但是用 new 分配数组空间时不能指定初值;
    
    2. delete 运算符的一般格式:
    
        delete []指针变量;    //    注: 此处为指针变量;
如:
        delete p;
        
         char *pt = new char[10];
        delete[] pt;        //    指针变量前加[] 表示对数组空间的操作;


struct Student
{
char name[10];
int num;
char sex;};
int main()
{
Student *p;
p = new Student;strcpy(p->name,"ZK");
p->num = 100;
p->sex = 'F';cout << p->name << ' ' << p->num << ' ' << p->sex << endl;delete p;return 0;
}    若由于内存不足等原因无法正常分配空间,则new 会返回一个NULL指针;
    用户可以用此来判断是否正确分配;
    
注:    new 和 delete 为运算符,而malloc 和 free 为函数!

最新文章

123

最新摄影

闪念基因

微信扫一扫

第七城市微信公众平台