C++入门基础第一天

一、C++概述

C++是C语言的继承，贝尔实验室的Bjarne Stroustrup博士，1982年，他和他的同事基于C语言基础之上，发展C++,刚开始C++又叫作C witch class(带类的C)，C++ —> c plus plus,对于C++而言，主要对于C从两个方面带加强和扩展。最后，重新取名为C++.c++语言是一种混合型语言，它保留了C语言的所有优点，同时，又增加了面向对象的机制，从而使得程序的设计效率更加高效。

1）C++对C语言原有的增强
语法合法性
对关键字const
在原来的基础之上，增加了引用，命名空间，域操作符，bool ，字符串类型-string
2）C++为了更加高效的开发，提出了更好的面向对象机制

二、C++程序基本结构分析

源文件：.cpp .cc .cxx
文头文件: .h .hpp(第三方库中出现的比较，即可以包含类的声明，也可以包含类的设计)

#include <iostream>// 头文件
using namespace std; //使用命名空间-- std
//思考：int main(void)和int main() 区别
int main() //程序入口，C语言  int main(void)
{
    cout << "Hello World!" << endl; //输出一个字符串 "Hello World!"
    return 0;
}

i ----- in ---- 输入 o — out ---- 输出，输入和输出是以流(stream)来进行，所以就无需指定输入和输出数据的格式化（%d,%s）

三、cout,cin,endl的用法

#include <iostream> //相当于C语言 #incude <stdio.h>
using namespace std;
int main()
{
    //cout << "Hello World!" << endl;
    int i;
    char c;
    //cin就相当于键盘， >> 代表数据的流向 从键盘上输入的值给i 和 c,输入的顺序跟变量的顺序要保持一致
    cout << "please input:";
    cin >> i >> c; // 方法一 please input:10 a ---- 输入时用空格间隔起来
                   // 方法二 please input:10 a ---- 输入一个完成时，按回车，进行下一个操作数输入
    cout << "i = " << i << "c = " << c << endl;
    cout << &i << &c;
    return 0;
}

四、C++类型之扩展：string 和 bool

//在C语言中，本身不提供专门的字符串类型，通过字符数组和字符指针来处理字符串
//在C++中，它有了一个更好的解决办法，通过string类型来处理字符串
//所以string就是一个类类型，它就是一个类，读者就把它看作一个类型
int main()
{
    // class basic_string{} ---->  typedef basic_string<char>    string;
    //string 是类型basic_string<char>的别名，basic_string<char>它是一个类
    string s; //声明一个字符串类型变量 先声明，后赋值
    s = "hello";
    string s1 = " world"; //声明并且赋值

    string s2 = s1; //使用已有变量给新声明的变量赋值
    cout << s << endl;
    cout << s1 << endl;
    cout << s2 << endl;

    // int k = i + j;

    string s3 = s + s1; //两个字符串相加
    cout << s3 << endl;

    //对于字符串的其他操作：查找，比较，删除，切割,在类和对象之后，再深入进行讲解

    //[2] 在C++中,提供布尔类型  真：true(1)--- 值只能为1  假：(false) --- 值只能为0
    bool isok = true; //或者 false  true --- 1  false --- 0

    cout << "isok = " << isok;

    isok = -100;
     cout << endl;
    cout << "isok = " << isok;

    isok = 100;
     cout << endl;
    cout << "isok = " << isok;
    cout << endl;
    bool isopen = false;
    cout <<isopen << endl; //0

    cout << endl;
    isopen = 100;
    cout <<isopen << endl; //1,如果一个bool变量的初始值为false，当重新给它赋值时，非零时，值1
    cout << endl;
    isopen = -100;
    cout <<isopen << endl;


    cout << endl;
    isopen = 0;
    cout <<isopen << endl;

    bool istest1 = true;
    bool istest2 = false;

    bool is = istest1 && istest2; //有意义
    return 0;
}

五、引用

引用的应用：
1）函数的形参 -----好处在于节省空间，传址效率要高于传值
2）函数的返回值 ---- 返回的变量：静态变量和全局变量，不建议返回malloc和C++提供新的

1. 什么是引用：
   在C++中，引入引用，引用是一种关系型声明的类型，它所声明的变量不占空间，通俗来讲它就是已有变量的别名，来说明跟已有变量的关系，所以引用变量的类型要跟已有变量的类型保持一致。
   2.引用的基本语法
   语法：type &引用名(引用变量名)=已有的变量名

int i = 10;//给变量i取一个别名
int & ri = i; //声明了ri和i的关系，ri是变量的i的别名，
//这样做的好处，可以通过引用名来访问已有变量(i)的内存空间，他们是同一个人

引用使用规则:
1.引用没有定义，只是一种关系型声明，不分配内存
2.引用是变量的别名，那么在声明引用变量时，一定要初始化（引用做为函数形参除外），一经声明， 不可变更（引用做为函数形参除外）

1. 可对引用，再次引用，多次引用的结果，是某一个变量有多个别名而已
2. &符号前有数据类型时为引用，其他情况下，为取地址

3 .引用的应用
引用是一种类型，那么引用可以声明变量、做为函数形参和做为函数的返回值
1）引用做为函数的形参
修改一个变量值
2）指针引用
指针也是一种类型，指针是用来指向某种类型
指针引用的语法：type* & ----> 可以起到二级指针效果
4 引用做为函数返回值

#include <iostream>

using namespace std;

//引用做为函数的返回值(静态变量或者全局变量,malloc )
int& getvalue()
{
    //局部变量：当函数getvalue调用结束后，a变量所代表空间，
    //被系统回收，该内存是未知
    //所以引用做为函数返回值时，不能返回局部变量，返回的是一个有效的内存地址	(静态变量或者全局变量,malloc )
    int a = 10;
    return  a; //不可以
}

int& getvalue2()
{
    static int a = 10;
    return a; //ok
}

//全局变量
int global_test = 20;
int& getvalue3()
{
    return  global_test;
}
int main()
{

    int & a_r = getvalue2();

    int global_r = getvalue3();

    return 0;
}

5.const引用
因为引用可以用来做函数的参数，而函数的形参可以使用const来修饰，所以也可以使用const来修饰引用---- const引用
普通引用:type& 引用名 = 已有变量（普通变量）
const引用：const type& 引用名 = const修饰的已有变量、普通变量

void func( const string& str)
{
    cout << str << endl;
    //保证在该函数中不修改，接受常量的传递
}

int main()
{
    //普通引用
    int i = 10;

    int& ri = i;
     ri = 20;
     cout << "i = " << i << "ri = " << ri<<endl;
    const int j = 20;  //变量j拥有了const品质--- 只读
    //j的类型是什么---const int
    const int& rj = j; //严格意义上来讲，const 引用要使用const变量来进行初始化
     //rj = 30; //error ----> rj类型为const int&
    const int& rri = i; //使用普通变量初始化const引用

    //普通引用与const引用最大区别
    int a = 10;
   // int& ra = 20; // error 不能使用常量来初始化普通引用
    const int& rb = 20; //ok 可以使用常量（字面常量）来初始化const引用

    string s = "hello";

    func(s);

    func("hello");

    return 0;
}
结论：如果是局部变量并且是基本数据类型，直接变量普通变量更加方便，不推荐使用
     引用
     int i = 10;
     int& j = i; //没有必要
     j = 20; //没有必要
     i = 20;

引用的本质就是一个指针常量 语法：type& 引用名 = 已有变量; 比如：
int i = 10;
int& ri = i; //ri就只能指向i，不能再去指向另外变量
type & 本质 -----> type * const(指针常量)，指向的对象不可改变，但指向的内存地址内容是可以改变 const type* 和 type const 等价 ----> 常量指针，指向的对象可以改变，但是指向的内存地址内容是不可改变（常量） const typeconst

void test1(int*const p)
{
    //如果该指针p可以指向别外内存地址，p可以进行++
   // p++; //error
    (*p)++; //ok
}

void test2(int& p)
{
     p = 10;


}

**

第一天完!

**