MENU

C++重学之路(一)

June 15, 2020 • Read: 1024 • C/C++阅读设置

知识记录文,mark,持续更新。

0x00 一个简单的C++程序结构

首先粘一段简单的C++代码:

#include <iostream>
using namespace std;
 
// main() 是程序开始执行的地方
 
int main()
{
   cout << "Hello World" << endl; // 输出 Hello World
   return 0;
}

程序的流程结构:顺序、选择、循环。

代码从上到下就是顺序结构。

从本段代码的头行开始:

#include <iostream>

包含了名叫iostream的头文件。

头文件作为一种包含功能函数、数据接口声明的载体文件,通常编译器通过头文件找到对应的函数库,把引用的函数实际内容导出来。

这里用<>尖括号表示引用标准库的头文件,如果这里替换为""双引号表示引用非标准库的头文件。

这里的iostream表示输入输出流,是标准的C++头文件,任何C++使用输入(cin)输出(cout)都要用到这个。

新的C++标准通常不会使用C的头文件命名.h的后缀格式,没有.h的头文件依然可以用命名空间。

所以需要用到:

using namespace std;

这是用到了using编译指令,告诉编译器使用 std 命名空间。

如果只想单独使用std命名空间内的,那么可以这样使用:

using std::cout;
using std::cin;
using std::endl;

再往下:

// main() 是程序开始执行的地方

C++中用//表示单行注释。

而后面:

int main()

表示主函数,是程序开始执行的地方。

主函数{}表示作用域。

cout << "Hello World" << endl;

cout表示输出流,<<表示插入运算符,把右边的信息插入到流中。endl表示控制符,可以换行。整条语句表示输出Hello World

return 0;

终止 main( )函数,并向调用进程返回值 0。

0x01 注释

通常情况下我们会对程序内部某部分的逻辑加上一些说明,增加代码的可读性,而这些部分不需要被编译,那么就用到了注释。

1.单行注释:

// 123123

2.多行注释:

/* 这是注释 */
 
/* C++ 注释也可以
 * 跨行
 */

0x02 数据类型

七种基本的 C++ 数据类型:

类型关键字
布尔型bool
字符型char
整型int
浮点型float
双浮点型double
无类型void
宽字符型wchar_t

数据类型的总结:

看菜鸟教程的记录。

C++ 数据类型

操作数类型的隐式转换规则:

1、有long double,转long double;
2、有double,转double;
3、有float,转float;
4、有unsigned long,转unsigned long;
5、有long,转long;
6、有unsigned int,转unsigned int;
7、有int,转int。

手工类型转换:

static_cast<type>(value);

int i = 0; int j = (long)i;// C风格的类型转换

0x03 转义字符

字符含义
\b退格
\t制表
\n换行
\f换页
\r回车
\\反斜线
\'单引号
\"双引号

0x04 面向过程与面向对象

1.面向过程

面向过程是一种以过程为中心的编程思想。

通过分析出解决问题所需要的步骤,然后用函数把这些步骤一步一步实现,使用的时候一个一个依次调用就可以了。

面向过程编程思想的核心:功能分解,自顶向下,逐层细化(程序=数据结构+算法)。

面向过程编程语言存在的主要缺点是不符合人的思维习惯,而是要用计算机的思维方式去处理问题,而且面向过程编程语言重用性低,维护困难。

2.面向对象

面向对象编程(Object-Oriented Programming)简称 OOP 技术,区别于面向过程编程常常把所有代码放到几个模块中,造成了程序的难以维护和难以阅读。

而使用OOP技术,通常会用到很多代码模块,代码模块只提供特定的功能,彼此独立,这样就可以增加代码的重用性,便于程序的开发维护和更新。

面向对象编程的本质是设计并扩展自己的数据类型。

在面向对象中,算法和数据结构被当作一个整体,称为对象。世间一切皆为对象,不同类的对象有自己特定的属性和操作。

用等式来定义对象和程序:

对象 = 算法 + 数据结构

程序 = 对象 + 对象 + ……

面向对象编程思想的核心:应对变化,提高复用。

面向对象的编程语言的特性:封装、继承、多态。

0x05 函数

1.函数重载

感觉跟Java他们都一样,可以定义一组名称相同而参数不同的函数。

例子:

void print(char const* myString)
{
    printf("String %s\n", myString);
}

void print(int myInt)
{
    printf("My int is %d", myInt);
}

int main()
{
    print("Hello"); // 解析为 void print(const char*)
    print(15); // 解析为 void print(int)
}

2.参数默认值

可以为函数的参数指定一个默认的值,在调用函数时如果没有被提供参数值,将会使用指定的默认参数值。

注意,如果要指定默认值,当有两个以上的参数时,不能只给一个参数赋值。

例:

void add(int a = 5, int b = 10)
{
    // 对两个参数进行一些操作
}

int main()
{
    add();      // a = 5,  b = 10
    add(20);    // a = 20, b = 10
    add(20, 5); // a = 20, b = 5
}

0x06 命名空间

命名空间为变量、函数和其他声明提供了分离的的作用域。

命令空间找个例子方便理解,引入这个特性是C++为了解决合作开发时的命名冲突问题。

比如,小李和小韩都参与了一个文件管理系统的开发,它们都定义了一个全局变量 fp,用来指明当前打开的文件,将他们的代码整合在一起编译时,很明显编译器会提示 fp 重复定义(Redefinition)错误。

小李与小韩各自定义了以自己姓氏为名的命名空间,此时再将他们的 fp 变量放在一起编译就不会有任何问题。

namespace Li{  //小李的变量定义
    FILE fp = NULL;
}
namespace Han{  //小韩的变量定义
    FILE fp = NULL
}

并且命名空间可以嵌套使用。

namespace First {
    namespace Nested {
        void hello()
        {
            printf("This is First::Nested::hello\n");
        }
    } // 结束嵌套的命名空间Nested
} // 结束命名空间First

namespace Second {
    void hello()
    {
        printf("This is Second::hello\n")
    }
}

void hello()
{
    printf("This is 全局 hello\n");
}

int main()
{
    // 在使用当前命令空间后,如果没有特别指定,就从“Second”中取得所需的内容。
    using namespace Second;

    hello(); // 显示“This is Second::hello”
    First::Nested::hello(); // 显示“This is First::Nested::hello”
    ::hello(); // 显示“This is 全局 hello”
}

0x07 输入输出

C++使用“流”来输入输出。

<<是流的插入运算符。

>>是流提取运算符。

对象代表
cinstdin(标准输入)
coutstdout(标准输出)
cerrstderr(标准错误)

例:

#include <iostream> // 引入包含输入/输出流的头文件

int main()
{
   int myInt;

   // 在标准输出(终端/显示器)中显示
   cout << "请输入一个数字:\n";
   // 从标准输入(键盘)获得一个值
   cin >> myInt;
   // cout也提供了格式化功能
   cout << "你输入的数字为:" << myInt << "\n";
   // 显示“你输入的数字为:<myInt>”
   cerr << "这里是错误信息";
}

0x08 字符串

C++提供了string类,是C++标准库的重要组成部分,提供了很多成员函数,主要就是用于字符串处理。

例:

#include <iostream>
#include <string>

using namespace std; // 字符串也在std命名空间(标准库)中。

string myString = "Hello";
string myOtherString = " World";

// + 可以用于连接字符串。
cout << myString + myOtherString; // "Hello World"

cout << myString + " You"; // "Hello You"

// C++中的字符串是可变的,具有“值语义”。
// append函数是向string的后面追加字符或字符串。
myString.append(" Dog");
cout << myString; // "Hello Dog"

0x09 C++引用

引用是一种特殊的指针类型。可以当作某个已存在变量的另一个名字。

引用一旦被定义就不能重新赋值,并且不能被设置为空值。

使用引用时的语法与原变量相同。

例:

#include <iostream>
 
using namespace std;
 
int main ()
{
   // 声明简单的变量
   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;
   
   return 0;
}

1.把引用作为返回值

1.引用作为函数的返回值时,必须在定义函数时在函数名前将&加上

2.用引用作函数的返回值的最大的好处是在内存中不产生返回值的副本

#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 个元素的引用
}
 
// 要调用上面定义函数的主函数
int main ()
{
 
   cout << "改变前的值" << endl;
   for ( int i = 0; i < 5; i++ )
   {
       cout << "vals[" << i << "] = ";
       cout << vals[i] << 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;
}

2.把引用作为参数

场景:

1、C++提供了 传递变量的引用。形参是引用变量,和实参是一个变量,调用函数时,形参(引用变量)指向实参变量单元。这种通过形参引用可以改变实参的值。

#include <iostream>
using namespace std;
 
// 函数声明
void swap(int& x, int& y);
 
int main ()
{
   // 局部变量声明
   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;
 
   return 0;
}
 
// 函数定义
void swap(int& x, int& y)
{
   int temp;
   temp = x; /* 保存地址 x 的值 */
   x = y;    /* 把 y 赋值给 x */
   y = temp; /* 把 x 赋值给 y  */
  
   return;
}

0x10 类与对象

例子:

#include <iostream>

// 声明一个类。
// 类通常在头文件(.h或.hpp)中声明。
class Dog {
    // 成员变量和成员函数默认情况下是私有(private)的。
    std::string name;
    int weight;

// 在这个标签之后,所有声明都是公有(public)的,
// 直到重新指定“private:”(私有继承)或“protected:”(保护继承)为止
public:

    // 默认的构造器
    Dog();

    // 这里是成员函数声明的一个例子。
    // 可以注意到,我们在此处使用了std::string,而不是using namespace std
    // 语句using namespace绝不应当出现在头文件当中。
    void setName(const std::string& dogsName);

    void setWeight(int dogsWeight);

    // 如果一个函数不对对象的状态进行修改,
    // 应当在声明中加上const。
    // 这样,你就可以对一个以常量方式引用的对象执行该操作。
    // 同时可以注意到,当父类的成员函数需要被子类重写时,
    // 父类中的函数必须被显式声明为_虚函数(virtual)_。
    // 考虑到性能方面的因素,函数默认情况下不会被声明为虚函数。
    virtual void print() const;

    // 函数也可以在class body内部定义。
    // 这样定义的函数会自动成为内联函数。
    void bark() const { std::cout << name << " barks!\n" }

    // 除了构造器以外,C++还提供了析构器。
    // 当一个对象被删除或者脱离其定义域时,它的析构函数会被调用。
    // 这使得RAII这样的强大范式(参见下文)成为可能。
    // 为了衍生出子类来,基类的析构函数必须定义为虚函数。
    virtual ~Dog();

}; // 在类的定义之后,要加一个分号

// 类的成员函数通常在.cpp文件中实现。
void Dog::Dog()
{
    std::cout << "A dog has been constructed\n";
}

// 对象(例如字符串)应当以引用的形式传递,
// 对于不需要修改的对象,最好使用常量引用。
void Dog::setName(const std::string& dogsName)
{
    name = dogsName;
}

void Dog::setWeight(int dogsWeight)
{
    weight = dogsWeight;
}

// 虚函数的virtual关键字只需要在声明时使用,不需要在定义时重复
void Dog::print() const
{
    std::cout << "Dog is " << name << " and weighs " << weight << "kg\n";
}

void Dog::~Dog()
{
    std::cout << "Goodbye " << name << "\n";
}

int main() {
    Dog myDog; // 此时显示“A dog has been constructed”
    myDog.setName("Barkley");
    myDog.setWeight(10);
    myDog.print(); // 显示“Dog is Barkley and weighs 10 kg”
    return 0;
} // 显示“Goodbye Barkley”

1.类的定义

类的定义:类是对象的抽象和概括,而对象是类的具体和实例。

C++中类的其实就是包含函数的结构体。因为C++类里面的成员除了可以像C语言的结构体那样包含基本变量以外,还可以包含函数,前者叫做成员变量,后者叫做成员方法(函数)。

2.成员函数

上例子中所写的:

就是一个非常典型的成员函数。

void Dog::print() const
{
    std::cout << "Dog is " << name << " and weighs " << weight << "kg\n";
}

3.构造函数

构造函数是类中很重要的一个函数,构造函数常用于处理对象段初始化。

这里举一个学生类的例子。

构造函数在类里,与类名同名,且没有返回值的一个函数,只要我们定义一个类的对象,系统就会自动调用它,进行专门的初始化对象用。

而大多数情况下,因为我们没有定义构造函数,系统会默认生成一个默认形式、隐藏着的构造函数,这个构造函数的函数体是空着的,因此不具有任何功能。

这里增加了带有三个默认参数的构造函数。可以看到main中实例化一个对象A并赋初始值。

#include<iostream>
#include<Cstring>
using namespace std;
class Student
{
    private:
    int num;//学号
    char name[100];//名字
    int score;//成绩
    public:
    Student(int n,char *str,int s);
    int print();
    int Set(int n,char *str,int s);
};
Student::Student(int n,char *str,int s)
{
     num = n;
     strcpy(name,str);
     score = s;
cout<<"Constructor"<<endl;
}
int Student::print()
{
    cout<<num<<" "<<name<<" "<<score;
    return 0;
}
int Student::Set(int n,char *str,int s)
{
     num = n;
     strcpy(name,str);
     score = s;
}
int main()
{
    Student A(100,"dotcpp",11);
    A.print();
    return 0;
}

4.析构函数

类对象在创建时自动调用的构造函数,在对象销毁时也会自动调用一个函数,它也和类名同名,也没有返回值,名字前有一个个波浪线~,用来区分构造函数,它的作用主要是用做对象释放后的清理善后工作。

对比构造函数:

相同点:与类名相同,没有返回值,如果用户不定义,系统也会自动生成一个空的析构函数。而一旦用户定义,则对象在销毁时自动调用。

不同点:虽然他俩都为公开类型。构造可以重载,有多个兄弟,而析构却不能重载,但它可以是虚函数,一个类只能有一个析构函数。

5.this指针

概念同Java中的this,对象中的隐藏的this指针,可以明确是本类中的成员,从而明显的区别本对象与外部变量。

void Dog::setWeight(int dogsWeight)
{
    this->weight = dogsWeight;
}
// 或者这样用
void Dog::setWeight(int dogsWeight)
{
    (*this).weight = dogsWeight;
}

未完待续。

原文作者:Keefe

原文链接:C++重学之路(一)

版权声明:本文采用知识共享署名-非商业性使用 4.0 国际许可协议进行许可

Last Modified: August 11, 2020