C++基础

1.C++基本语法、注释、数据类型、变量作用域、常量

对象 - 对象具有状态和行为。例如:一只狗的状态 - 颜色、名称、品种,行为 - 摇动、叫唤、吃。对象是类的实例。
 类 - 类可以定义为描述对象行为/状态的模板/蓝图。
 方法 - 从基本上说,一个方法表示一种行为。一个类可以包含多个方法。可以在方法中写入逻辑、操作数据以及执行所有的动作。
 即时变量 - 每个对象都有其独特的即时变量。对象的状态是由这些即时变量的值创建的。
 
 c++标识符:用来标识变量、函数、类、模块,或任何其他用户自定义项目的名称。一个标识符以字母 A-Z 或 a-z 或下划线 _ 开始,后跟零个或多个字母、下划线和数字(0-9)。
 C++标识符内不允许出现标点字符,比如 @、& 和 %。C++ 是区分大小写的编程语言。
 
 c++注释:单行和多行
 /* 这是注释 */

/* C++ 注释也可以
 * 跨行
 * /
 
 C++七种基本数据类型:bool(true false)、char、int、float、double、void、wchar_t(宽字符)
 一些基本类型可以使用一个或多个类型修饰符进行修饰:signed、unsigned、short、long
 
 typedef声明:使用 typedef 为一个已有的类型取一个新的名字:typedef type newname;
 
 枚举类型:由用户定义的若干枚举常量的集合。
 enum 枚举名{
    标识符[=整型常数],
    标识符[=整型常数],
    标识符[=整型常数],
    标识符[=整型常数],
 }枚举变量;
 
 变量是程序可操作的存储区的名称。C++ 中每个变量都有指定的类型,类型决定了变量存储的大小和布局,该范围内的值都可以存储在内存中,运算符可应用于变量上。
 变量定义与初始化:type variable_name = value;      int d = 3;
 作用域是程序的一个区域,一般来说有三个地方可以定义变量:
    在函数或一个代码块内部声明的变量,称为局部变量。
    在函数参数的定义中声明的变量,称为形式参数。
    在所有函数外部声明的变量,称为全局变量。
 
 常量是固定值,在程序执行期间不会改变。这些固定的值,又叫做字面量。
 定义常量:1.使用#define预处理器 2.使用const关键字
#include <iostream>
using namespace std;

#define LENGTH 10 //定义常量

//枚举
enum times{
    first,
    second,
    third
}tm;

int g = 20;//全局变量

int main(int argc, const char * argv[]) {
    int a = 10;//局部变量
    
    std::cout << "Hello, World!\n";
    cout << a <<"\n";
    
    const int WIDTH = 5;//定义常量
    int area = LENGTH * WIDTH;
    cout << area <<"\n";
    
    tm = first;
    switch (tm) {
        case first:
            cout<<"first\n";
            break;
        case second:
            cout<<"second\n";
            break;
        case third:
            cout<<"third\n";
            break;
        default:
            break;
    }
    
    return 0;
}
81.png

2.c++存储类

C++存储类:
    存储类定义 C++ 程序中变量/函数的范围(可见性)和生命周期。这些说明符放置在它们所修饰的类型之前。
    包括:auto、register、static、extern、mutable、thread_local(C++11)
    auto 关键字用于两种情况:声明变量时根据初始化表达式自动推断该变量的类型、声明函数时函数返回值的占位符。
        auto f = 3.14; //double
        auto z = new auto(9); //int*
        auto s("hello"); //const char*
    register存储类用于定义存储在寄存器中而不是 RAM 中的局部变量。
    static:指示编译器在程序的生命周期内保持局部变量的存在,而不需要在每次它进入和离开作用域时进行创建和销毁。因此,使用 static 修饰局部变量可以在函数调用之间保持局部变量的值。
        static 修饰符也可以应用于全局变量。当 static 修饰全局变量时,会使变量的作用域限制在声明它的文件内。
    extern:用于提供一个全局变量的引用,全局变量对所有的程序文件都是可见的。
    mutable 说明符仅适用于类的对象.
    thread_local 说明符声明的变量仅可在它在其上创建的线程上访问。 变量在创建线程时创建,并在销毁线程时销毁。 每个线程都有其自己的变量副本。


#include <iostream>

// 函数声明
void func(void);
static int count = 5; //静态全局变量

int main(int argc, const char * argv[]) {
    while(count--)
    {
        func();
    }
    return 0;
}

// 函数定义
void func( void )
{
    static int i = 5; // 局部静态变量
    i++;
    std::cout << "变量 i 为 " << i ;
    std::cout << " , 变量 count 为 " << count << std::endl;
}
82.png

3.运算符

 C++运算符
    算术运算符:+、-、*、/、%、++、--。加、减、乘、除、取模、自增、自减。
 
    关系运算符:==、!=、>、<、>=、<=。相等、不相等、大于、小于、大于等于、小于等于
 
    逻辑运算符:&&、||、! 逻辑与、逻辑或、逻辑非
 
    位运算符:&、|、^、~、<<、>>、 与、或、异或、翻转位、左移、右移
 
    赋值运算符:=、+=、-=、*=、/=、%=、<<=、>>=、&=、^=、|=
 
    杂项运算符:
        sizeof运算符返回变量的大小。
        Condition ? X : Y 条件运算符,如果 Condition 为真 ? 则值为 X : 否则值为 Y。
        .(点):成员运算符用于引用类、结构和共用体的成员。
        &:指针运算符 & 返回变量的地址。
        *:指针运算符 * 指向一个变量。

4.循环和判断

C++循环
    循环类型:
        while循环
        for循环
        do…while循环
    循环控制语句:
        break:终止 loop 或 switch 语句,程序流将继续执行紧接着 loop 或 switch 的下一条语句。
        continue:引起循环跳过主体的剩余部分,立即重新开始测试条件。
 C++判读
    判断语句:
        if语句
        if…else语句
        switch语句
    ?:运算符:
        exp1 ? exp2 : exp3;

5.函数

/*
C++函数
    函数是一组一起执行一个任务的语句。每个 C++ 程序都至少有一个函数,即主函数 main()。
    定义函数:
        return_type function_name(parameter list){
            body
        }
        返回类型
        函数名称
        参数
        函数主体
    函数参数:
        如果函数要使用参数,则必须声明接受参数值的变量。这些变量称为函数的形式参数。
        形式参数就像函数内的其他局部变量,在进入函数时被创建,退出函数时被销毁。
        当调用函数时,有两种向函数传递参数的方式:
            传值调用:该方法把参数的实际值复制给函数的形式参数。在这种情况下,修改函数内的形式参数对实际参数没有影响。
            指针调用:该方法把参数的地址复制给形式参数。在函数内,该地址用于访问调用中要用到的实际参数。这意味着,修改形式参数会影响实际参数。
            引用调用:该方法把参数的引用复制给形式参数。在函数内,该引用用于访问调用中要用到的实际参数。这意味着,修改形式参数会影响实际参数。

 */

#include <iostream>

int sum(int a, int b){
    int result;
    result = a + b;
    return result;
}

int main(int argc, const char * argv[]) {
    
    int a = 1;
    int b = 2;
    int result = sum(a, b);
    std::cout<<"total value is:"<<result;

    return 0;
}

6.数组

/*
C++数组
    它可以存储一个固定大小的相同类型元素的顺序集合。
    声明数组:type arrayName [arraySize];
 
 */

#include <iostream>
using namespace std;

int main(int argc, const char * argv[]) {
    
    int n[10] = {1,2,3,4,5,6,7,8,9,10};//声明并初始化数组
    
    int sum = 0;
    for(int i = 0; i<10;i++){
        sum = sum + n[i];
    }
    cout<<"sum = "<<sum<<"\n";

    return 0;
}

7.字符串

/*
C++字符串
    c风格字符串
    C++引入的string类类型
    字符转函数:
        strcpy(s1, s2);复制字符串 s2 到字符串 s1。
        strcat(s1, s2);连接字符串 s2 到字符串 s1 的末尾。
        strlen(s1);返回字符串 s1 的长度。
        strcmp(s1, s2);如果 s1 和 s2 是相同的,则返回 0;如果 s1<s2 则返回小于 0;如果 s1>s2 则返回大于 0。
        strchr(s1, ch);返回一个指针,指向字符串 s1 中字符 ch 的第一次出现的位置。
        strstr(s1, s2);返回一个指针,指向字符串 s1 中字符串 s2 的第一次出现的位置。
 */

#include <iostream>
using namespace std;

int main(int argc, const char * argv[]) {
    
    char str1[11] = "Hello";
    char str2[11] = "World";
    char str3[11];
    long  len ;
    
    // 复制 str1 到 str3
    strcpy( str3, str1);
    cout << "strcpy( str3, str1) : " << str3 << endl;
    
    // 连接 str1 和 str2
    strcat( str1, str2);
    cout << "strcat( str1, str2): " << str1 << endl;
    
    // 连接后,str1 的总长度
    len = strlen(str1);
    cout << "strlen(str1) : " << len << endl;
    
    //c++中的string类
    string s1 = "hello";
    string s2 = "world";
    string s3;
    long leng;
    
    s3 = s1;
    cout<<"s3:"<<s3<<endl;
    
    s3 = s1 + s2;
    cout<<"s1+s2:"<<s3<<endl;
    
    leng = s3.size();
    cout<<"s3.size():"<<leng<<endl;

    return 0;
}
83.png

8.指针

/*
C++指针
 
    type *var-name;
    指针是一个变量,其值为另一个变量的地址,即,内存位置的直接地址。
    所有指针的值的实际数据类型,都是一样的,都是一个代表内存地址的长的十六进制数。
    不同数据类型的指针之间唯一的不同是,指针所指向的变量或常量的数据类型不同。
    int    *ip;    一个整型的指针
    double *dp;    一个 double 型的指针
    float  *fp;     一个浮点型的指针
    char   *ch;     一个字符型的指针
 
 */

#include <iostream>
using namespace std;

int main(int argc, const char * argv[]) {
    int  var = 20;   // 实际变量的声明
    int  *ip;        // 指针变量的声明
    
    ip = &var;       // 在指针变量中存储 var 的地址
    
    cout << "Value of var variable: ";
    cout << var << endl;
    
    // 输出在指针变量中存储的地址
    cout << "Address stored in ip variable: ";
    cout << ip << endl;
    
    // 访问指针中地址的值
    cout << "Value of *ip variable: ";
    cout << *ip << endl;
    
    return 0;
}
84.png

9.引用

/*
C++引用
    引用变量是一个别名,也就是说,它是某个已存在变量的另一个名字。一旦把引用初始化为某个变量,就可以使用该引用名称或变量名称来指向变量。
    C++ 引用 vs 指针:
        不存在空引用。引用必须连接到一块合法的内存。
        一旦引用被初始化为一个对象,就不能被指向到另一个对象。指针可以在任何时候指向到另一个对象。
        引用必须在创建时被初始化。指针可以在任何时间被初始化。
    引用通常用于函数参数列表和函数返回值。
 */

#include <iostream>
using namespace std;

double vals[] = {10.1, 12.6, 33.1, 24.1, 50.0};

double& setValues( int i )
{
    return vals[i];   // 返回第 i 个元素的引用
}

// 函数定义
void swap(int& x, int& y)
{
    int temp;
    temp = x; /* 保存地址 x 的值 */
    x = y;    /* 把 y 赋值给 x */
    y = temp; /* 把 x 赋值给 y  */
    
    return;
}

int main(int argc, const char * argv[]) {
    // 声明简单的变量
    int i;
    double d;
    // 声明引用变量
    int& r = i;
    double& s = d;
    
    i = 5;
    cout << "Value of i : " << i << endl;
    cout << "Value of i reference : " << r  << endl;
    
    d = 11.7;
    cout << "Value of d : " << d << endl;
    cout << "Value of d reference : " << s  << endl;
    
    //把引用用作参数
    // 局部变量声明
    int a = 100;
    int b = 200;
    
    cout << "交换前,a 的值:" << a << endl;
    cout << "交换前,b 的值:" << b << endl;
    
    /* 调用函数来交换值 */
    swap(a, b);
    
    cout << "交换后,a 的值:" << a << endl;
    cout << "交换后,b 的值:" << b << endl;
    
    //把引用作为返回值
    setValues(1) = 20.23; // 改变第 2 个元素
    setValues(3) = 70.8;  // 改变第 4 个元素
    
    cout << "改变后的值" << endl;
    for ( int i = 0; i < 5; i++ )
    {
        cout << "vals[" << i << "] = ";
        cout << vals[i] << endl;
    }
    return 0;
}
Snip20171013_85.png

10.结构体

/*
C++ 数据结构
    结构是 C++ 中另一种用户自定义的可用的数据类型,它允许您存储不同类型的数据项。
    定义结构:
        struct type_name {
        member_type1 member_name1;
        member_type2 member_name2;
        member_type3 member_name3;
        .
        .
        } object_names;
 
 */

#include <iostream>
using namespace std;

// 声明一个结构体类型 Books
struct Books
{
    char  title[50];
    char  author[50];
    char  subject[100];
    int   book_id;
};
//方式二:
/*
 typedef struct
 {
 char  title[50];
 char  author[50];
 char  subject[100];
 int   book_id;
 }Books;
 
 */

//结构作为函数参数
void printBook( struct Books book )
{
    cout << "书标题 : " << book.title <<endl;
    cout << "书作者 : " << book.author <<endl;
    cout << "书类目 : " << book.subject <<endl;
    cout << "书 ID : " << book.book_id <<endl;
}

int main(int argc, const char * argv[]) {
    Books Book1;        // 定义结构体类型 Books 的变量 Book1
    Books Book2;        // 定义结构体类型 Books 的变量 Book2
    
    // Book1 详述
    strcpy( Book1.title, "C++ 教程");
    strcpy( Book1.author, "Runoob");
    strcpy( Book1.subject, "编程语言");
    Book1.book_id = 12345;
    
    // Book2 详述
    strcpy( Book2.title, "CSS 教程");
    strcpy( Book2.author, "Runoob");
    strcpy( Book2.subject, "前端技术");
    Book2.book_id = 12346;
    
    // 输出 Book1 信息
    cout << "第一本书标题 : " << Book1.title <<endl;
    cout << "第一本书作者 : " << Book1.author <<endl;
    cout << "第一本书类目 : " << Book1.subject <<endl;
    cout << "第一本书 ID : " << Book1.book_id <<endl;
    
    // 输出 Book2 信息
    printBook( Book2 );
    
    return 0;
}
Snip20171013_86.png

推荐阅读更多精彩内容