学习c++的第二天

这篇具有很好参考价值的文章主要介绍了学习c++的第二天。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

目录

数据类型

基本数据类型

typedef 声明

枚举类型

类型转换

变量类型

变量定义

变量声明

左值(Lvalues)和右值(Rvalues)

变量作用域


数据类型

基本数据类型

C++ 为程序员提供了种类丰富的内置数据类型和用户自定义的数据类型。下表列出了七种基本的 C++ 数据类型:

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

wchar_t

类型修饰符:signed、unsigned、short、long
注:一些基本类型可以使用一个或多个类型修饰符进行修饰,比如:signed short int简写为short、signed long int 简写为long。

下表显示了各种变量类型在内存中存储值时需要占用的内存,以及该类型的变量所能存储的最大值和最小值。

注意:不同系统会有所差异,一字节为 8 位。默认情况下,int、short、long都是带符号的,即 signed。long int 8 个字节,int 都是 4 个字节,早期的 C 编译器定义了 long int 占用 4 个字节,int 占用 2 个字节,新版的 C/C++ 标准兼容了早期的这一设定。

类型 范围
char 1 个字节 -128 到 127 或者 0 到 255
unsigned char 1 个字节 0 到 255
signed char 1 个字节 -128 到 127
int 4 个字节 -2147483648 到 2147483647
unsigned int 4 个字节 0 到 4294967295
signed int 4 个字节 -2147483648 到 2147483647
short int 2 个字节 -32768 到 32767
unsigned short int 2 个字节 0 到 65,535
signed short int 2 个字节 -32768 到 32767
long int 8 个字节 -9,223,372,036,854,775,808 到 9,223,372,036,854,775,807
signed long int 8 个字节 -9,223,372,036,854,775,808 到 9,223,372,036,854,775,807
unsigned long int 8 个字节 0 到 18,446,744,073,709,551,615
float 4 个字节 精度型占4个字节(32位)内存空间,+/- 3.4e +/- 38 (~7 个数字)
double 8 个字节 双精度型占8 个字节(64位)内存空间,+/- 1.7e +/- 308 (~15 个数字)
long double 16 个字节 长双精度型 16 个字节(128位)内存空间,可提供18-19位有效数字。
wchar_t 2 或 4 个字节 1 个宽字符

注意,各种类型的存储大小与系统位数有关,但目前通用的以64位系统为主。

以下列出了32位系统与64位系统的存储大小的差别(windows 相同):

学习c++的第二天,C++,学习,c++,开发语言

typedef 声明

typedef是C和C++语言中的一个关键字,用于给一个已有的数据类型起一个新的别名。typedef可以提高代码可读性和可维护性。

typedef的语法如下:

typedef existing_type new_type_name;

其中,existing_type代表要起别名的已有数据类型,new_type_name代表新的别名。existing_type可以是任意合法的数据类型,包括基本数据类型、指针、结构体、联合体、枚举等。

typedef可以将一个复杂的数据类型(例如struct或者union)简化为一个易于使用和理解的名称,也可以定义新的类型名称以使得多个数据类型具有相同的类型名称,从而增加代码的清晰度。

下面是一些typedef的例子:

typedef int myint;   // 将 int 类型起个新的别名 myint
typedef float* pfloat;   // 将 float* 类型起个新的别名为 pfloat

// 用 typedef 定义结构体别名
typedef struct {
    char name[20];
    int age;
} Person;

// 用 typedef 定义枚举类型别名
typedef enum {
    Monday,
    Tuesday,
    Wednesday,
    Thursday,
    Friday,
    Saturday,
    Sunday
} Weekday;

在上面的例子中,myint是int类型的别名,pfloat是float*类型的别名。Person是一个结构体别名,可以通过Person代替struct { char name[20]; int age; }来定义结构体。Weekday是一个枚举类型的别名,可以通过Weekday代替enum { Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday }来定义枚举类型。

需要注意的是,typedef只是给一个已有的数据类型起一个新的别名,它并不会创建新的数据类型。因此,typedef语句不能用于定义新的变量,而只能用于定义新的类型名称。

枚举类型

枚举类型是C和C++中的一种数据类型,用于定义一个有限的、命名的整数值集合。枚举类型可以简化代码的可读性和维护性,同时提供了一种方式来表示一组相关的常量。

在C/C++中,定义一个枚举类型使用enum关键字,其语法如下:

enum enum_name {
    value1,
    value2,
    value3,
    // ...
};

其中,enum_name是枚举类型的名称,value1、value2、value3等是枚举常量,表示枚举类型的取值。每个枚举常量都会被编译器分配一个整数值,默认情况下从0开始递增。

以下是一个示例:

enum Color {
    RED,    // 0
    GREEN,  // 1
    BLUE    // 2
};

enum Weekday {
    Monday,     // 0
    Tuesday,    // 1
    Wednesday,  // 2
    Thursday,   // 3
    Friday,     // 4
    Saturday,   // 5
    Sunday      // 6
};

在上面的示例中,Color是一个枚举类型,它包含了三个枚举常量RED、GREEN和BLUE。默认情况下,RED的值是0,GREEN的值是1,BLUE的值是2。

同样地,Weekday是另一个枚举类型,它包含了七个枚举常量,分别代表星期一到星期日,它们的值从0到6递增。

在使用枚举类型时,可以通过枚举常量来表示具体的值。例如:

Color myColor = RED;
Weekday today = Wednesday;

上述代码中,myColor被赋值为RED,today被赋值为Wednesday。

需要注意的是,枚举常量的作用域是在所属的枚举类型中,并且枚举常量之间是唯一的。也可以通过显式地指定枚举常量的值来自定义枚举常量的整数值。例如:

enum Status {
    OK = 0,
    ERROR = -1,
    WARNING = 1
};

在这个示例中,Status是一个枚举类型,它包含了三个枚举常量OK、ERROR和WARNING,并且分别被赋予了整数值0、-1和1。

枚举类型在编程中经常用于表示一组相关的常量,增加代码的可读性和可维护性。它在switch语句中也常用于改善代码的可读性,使得程序更加清晰易懂。

类型转换

类型转换是将一个数据类型的值转换为另一种数据类型的值。

C++ 中有四种类型转换:静态转换、动态转换、常量转换和重新解释转换。

1、静态转换(Static Cast):
静态转换是一种编译时类型转换,在代码中使用 static_cast<type>(value) 的形式进行。它可以将基本数据类型或者用户定义的类型进行转换。静态转换通常用于比较宽松的类型转换,例如将一个指针转换为整数类型,或者将一个整数类型转换为枚举类型等。但需要注意的是,静态转换可能会导致数据精度损失或无效的转换,因此在进行类型转换时要谨慎使用,并确保转换操作是安全和合理的。

2、动态转换(Dynamic Cast):
动态转换是一种运行时类型转换,在代码中使用 dynamic_cast<type>(pointer) 的形式进行。它通常用于将一个基类指针或引用转换为派生类指针或引用。在进行动态转换时,需要注意转换操作的安全性,如果指针或引用不是指向实际对象,则转换操作会失败,返回空指针或引用。

3、常量转换(Const Cast):
常量转换是一种用于移除变量的常量属性或加上变量的常量属性的类型转换,使用 const_cast<type>(variable) 的形式进行。它通常用于解决一些编译器警告或者将 const 类型转换为非 const 类型的情况。但是需要注意,常量转换只能用于非常量变量上,否则会导致未定义的行为。

4、重新解释转换(Reinterpret Cast):
重新解释转换是一种类型转换,它可以将一个指针转换为另一个无关类型的指针,或者将一个整数类型转换为一个指针类型,使用 reinterpret_cast 进行。它通常用于将不同类型之间的二进制数据进行转换,但需要注意的是,这种转换可能会产生危险和未定义的行为,因此在使用时要格外小心。

下面是一个简单的代码示例,演示了在 C++ 中如何使用不同类型转换方式:

#include <iostream>
using namespace std;

int main() {
  // 静态转换
  int a = 10;
  double b = static_cast<double>(a);
  cout << "Static Cast: " << b << endl;

  // 动态转换
  class Base {
    public:
      virtual void print() {
        cout << "This is a Base class." << endl;
      }
  };
  class Derived : public Base {
    public:
      void print() {
        cout << "This is a Derived class." << endl;
      }
  };
  Base* base_ptr = new Derived;
  Derived* derived_ptr = dynamic_cast<Derived*>(base_ptr);
  if (derived_ptr != NULL) {
    derived_ptr->print();
  } else {
    cout << "Dynamic Cast Failed." << endl;
  }

  // 常量转换
  const int x = 5;
  int y = const_cast<int&>(x);
  y++;
  cout << "Const Cast: " << y << endl;

  // 重新解释转换
  int c = 100;
  void* ptr = reinterpret_cast<void*>(&c);
  int* d = reinterpret_cast<int*>(ptr);
  cout << "Reinterpret Cast: " << *d << endl;

  return 0;
}

输出结果如下:

Static Cast: 10
This is a Derived class.
Const Cast: 6
Reinterpret Cast: 100

该示例中分别使用了四种不同的类型转换方式,包括静态转换、动态转换、常量转换和重新解释转换。静态转换将整数类型转换为浮点数类型,动态转换将基类指针转换为派生类指针并调用其成员函数,常量转换将 const 类型的变量转换为非 const 类型的变量并修改其值,重新解释转换将整数类型的变量地址转换为 void 类型的指针并再次转换回整数类型的指针。通过该示例,可以更加深入地理解不同类型转换方式的使用方法和注意事项。

变量类型

1、整数类型(Integer Types):

  • int:用于表示整数,通常占用4个字节。
  • short:用于表示短整数,通常占用2个字节。
  • long:用于表示长整数,通常占用4个字节。
  • long long:用于表示更长的整数,通常占用8个字节。

2、浮点类型(Floating-Point Types):

  • float:用于表示单精度浮点数,通常占用4个字节。
  • double:用于表示双精度浮点数,通常占用8个字节。
  • long double:用于表示更高精度的浮点数,占用字节数可以根据实现而变化。

3、字符类型(Character Types):

  • char:用于表示字符,通常占用1个字节。
  • wchar_t:用于表示宽字符,通常占用2或4个字节。
  • char16_t:用于表示16位Unicode字符,占用2个字节。
  • char32_t:用于表示32位Unicode字符,占用4个字节。

4、布尔类型(Boolean Type):

  • bool:用于表示布尔值,只能取true或false。

5、枚举类型(Enumeration Types):

  • enum:用于定义一组命名的整数常量。

6、指针类型(Pointer Types):

  • type*:用于表示指向类型为type的对象的指针。

7、数组类型(Array Types):

  • type[]或type[size]:用于表示具有相同类型的元素组成的数组。

8、结构体类型(Structure Types):

  • struct:用于定义包含多个不同类型成员的结构。

9、类类型(Class Types):

  • class:用于定义具有属性和方法的自定义类型。

10、共用体类型(Union Types):

  • union:用于定义一种特殊的数据类型,它可以在相同的内存位置存储不同的数据类型。

11、其他类型:

  • 空类型(void):空类型表示无类型。
  • nullptr类型(nullptr):nullptr类型表示空指针。

12、引用类型:

  • 引用类型(int&,float&等)

注意:这些变量类型具有不同的特性和用途。基本数据类型用于存储单个数据值,复合数据类型可以存储多个相关数据值,指针类型和引用类型用于间接访问变量和内存地址,类类型用于创建自定义的对象类型,空类型表示无类型,nullptr类型表示空指针。

例如,以下是使用不同变量类型的示例:

#include <iostream>
using namespace std;

int main() {
  int age = 25; // 整数类型
  double salary = 5000.75; // 浮点数类型
  char grade = 'A'; // 字符类型
  bool isPassed = true; // 布尔类型

  int numbers[] = {1, 2, 3, 4, 5}; // 数组类型

  struct Person {
    string name;
    int age;
  };
  Person person1 = {"John", 30}; // 结构体类型

  enum Color { RED, GREEN, BLUE }; // 枚举类型
  Color color = GREEN;

  int* ptr = nullptr; // 指针类型
  int& ref = age; // 引用类型

  class Circle {
    double radius;
  };
  Circle c; // 类类型

  void* p = nullptr; // 空类型

  return 0;
}

在这个示例中,我们用不同的变量类型声明和初始化了变量。请注意,C++是一种静态类型语言,变量必须在使用之前显式声明其类型,并且不能在运行时更改其类型。

变量定义

在C++中,可以使用以下语法来定义变量:

type variable_name;       // 变量定义,不初始化
type variable_name = value;  // 变量定义,并初始化为特定的值

其中,type表示变量的数据类型(type 必须是一个有效的 C++ 数据类型,可以是 char、wchar_t、int、float、double、bool 或任何用户自定义的对象),variable_name表示变量的名称(variable_list 可以由一个或多个标识符名称组成,多个标识符之间用逗号分隔。),value表示变量的初始值。

以下是一些示例:

int age;                         // 定义一个整数变量age
double salary = 5000.75;         // 定义一个双精度浮点数变量salary并初始化为5000.75
char grade = 'A';                // 定义一个字符变量grade并初始化为'A'
bool isPassed = true;            // 定义一个布尔变量isPassed并初始化为true

int x, y, z;                     // 同时定义多个整数变量x, y, z
double pi = 3.14159, radius = 5; // 同时定义多个双精度浮点数变量pi, radius并初始化

注意事项:

  • 变量名必须遵循标识符的命名规则,且不能与C++的关键字重复。
  • 在定义变量时,可以选择是否对其进行初始化。未初始化的变量将具有不确定的值。
  • 可以在定义变量时使用赋值运算符 = 进行初始化,将特定的值赋给变量。
  • 在同一行上可以定义多个相同类型的变量,并用逗号 , 分隔它们。

值得一提的是,C++还支持在函数内部定义局部变量、在类中定义成员变量以及在命名空间中定义全局变量。这些变量定义的语法稍有不同,但基本原则和概念相同。

变量声明

在C++中,变量的声明是指在使用变量之前提前声明其存在,告诉编译器变量的类型和名称。变量声明只会创建变量的标识符,而不会分配内存空间或初始化变量。

以下是一些变量声明的例子:

1、声明整数变量:

extern int age;      // 声明一个整数变量age

2、声明浮点数变量:

extern double pi;   // 声明一个双精度浮点数变量pi

3、声明字符变量:

extern char grade;   // 声明一个字符变量grade

4、声明布尔变量:

extern bool isPassed;   // 声明一个布尔变量isPassed

5、声明字符串变量:

#include <string>      // 引入<string>头文件
using namespace std;

extern string name;    // 声明一个字符串变量name

需要注意的是,变量的声明通常与变量的定义分开。变量的定义是在声明的基础上为变量分配内存空间并可能进行初始化。变量的声明一般放在头文件中,以便在多个源文件中共享同一个变量。

例如,在一个名为 variables.h 的头文件中声明变量:

extern int age;        // 声明整数变量age
extern double pi;      // 声明双精度浮点数变量pi
extern char grade;     // 声明字符变量grade

然后,在源文件中进行变量的定义和初始化:

#include "variables.h"

int age = 25;          // 定义并初始化整数变量age
double pi = 3.14159;   // 定义并初始化双精度浮点数变量pi
char grade = 'A';      // 定义并初始化字符变量grade

这样,通过在源文件中包含声明的头文件,可以在不同的源文件中访问和使用这些变量。

左值(Lvalues)和右值(Rvalues)

在C++中,表达式可以分为左值(lvalues)和右值(rvalues)。左值和右值的主要区别在于它们在赋值操作符的左边或右边出现的位置。

左值(lvalue)是一个具有内存地址并且可以被引用的表达式。它可以出现在赋值操作符的左边或右边。换句话说,左值是一个可以被取址的表达式。典型的左值包括变量、对象成员以及通过解引用指针获得的值。

右值(rvalue)是一个临时的、不具有内存地址的表达式。它只能出现在赋值操作符的右边。右值通常是临时生成的值、字面量或表达式的结果。右值不能直接被引用,但可以通过将其绑定到右值引用(rvalue reference)来延长其生命周期。

C++11引入了右值引用(rvalue references),它们是一种新的引用类型,用于延长右值的生命周期并支持移动语义。通过将右值绑定到右值引用上,可以对其进行修改或移动。

下面是一些示例:

int x = 5;       // x是一个左值
int& lvalueRef = x;  // 左值引用可以引用左值

int y = x + 3;  // x+3是一个右值
int&& rvalueRef = x + 3;  // 右值引用可以引用右值

int z = std::move(x);  // std::move()将左值转换为右值引用

需要注意的是,C++中的一些情况下,左值可以被隐式地转换为右值,例如在函数返回语句中,即使左值也可以用作右值。

总结来说,左值是具有内存地址的表达式,可以出现在赋值操作符的左边或右边。右值是临时生成的、不具有内存地址的表达式,只能出现在赋值操作符的右边。右值引用类型可以绑定到右值,并支持对其进行修改或移动。

变量作用域

一般来说有三个地方可以定义变量:

  • 在函数或一个代码块内部声明的变量,称为局部变量。

  • 在函数参数的定义中声明的变量,称为形式参数。

  • 在所有函数外部声明的变量,称为全局变量。

1、全局作用域(Global Scope):在任何函数、代码块之外定义的变量具有全局作用域。这意味着它们在整个程序中都是可见和可访问的。全局变量在程序启动时被创建,在程序结束时销毁。

#include <iostream>

int globalVariable = 10;  // 全局变量

int main() {
    std::cout << globalVariable << std::endl;  // 可以在任何位置访问全局变量
    return 0;
}

2、块作用域(Block Scope):在函数或代码块内部定义的变量具有块作用域。这意味着它们只在定义它们的代码块内部是可见和可访问的。当代码块执行完毕后,变量将被销毁。

#include <iostream>

int main() {
    int x = 5;  // 块作用域的变量
    {
        int y = 10;  // 嵌套的块作用域的变量
        std::cout << x << " " << y << std::endl;  // 可以在代码块内部访问x和y
    }
    std::cout << x << std::endl;  // 只能在外层代码块内部访问x
    // std::cout << y << std::endl;  // 错误:y超出了作用域,无法访问
    return 0;
}

3、函数参数作用域(Function Parameter Scope):函数参数的作用域仅限于函数内部。它们在函数被调用时创建,并在函数执行完毕后销毁。

#include <iostream>

void myFunction(int param) {  // 参数param的作用域仅限于函数内部
    std::cout << param << std::endl;  // 可以在函数内部访问参数param
}

int main() {
    myFunction(5);
    // std::cout << param << std::endl;  // 错误:参数param的作用域仅限于函数内部,无法在main函数中访问
    return 0;
}

4、类作用域(Class Scope):在类定义内部声明的变量具有类作用域。它们可以被类中的任何成员函数访问。

#include <iostream>

class MyClass {
public:
    int classVariable;  // 类作用域的变量

    void myMethod() {
        std::cout << classVariable << std::endl;  // 可以在成员函数中访问类作用域的变量
    }
};

int main() {
    MyClass obj;
    obj.classVariable = 10;
    obj.myMethod();
    return 0;
}

需要注意的是,当在内部作用域中声明的变量与外部作用域中的变量同名,内部作用域的变量会隐藏外部作用域的同名变量。

变量的作用域是C++中管理变量可见性和访问性的重要概念。了解变量作用域对于编写正确和清晰的代码非常重要。文章来源地址https://www.toymoban.com/news/detail-740487.html

到了这里,关于学习c++的第二天的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 预计练习两年半的安全服务练习生的第二天

            form表单是HTML语言中用于向服务器提交信息的标签         常见属性 action 指定将表单数据发送到哪个URL method 指定提交表单数据的方法,常用的有GET和POST,一般我们用POST,区别是:POST将数据作为HTTP发送,GET将数据作为URL查询字符串发送 enctype encode type,当

    2024年02月13日
    浏览(46)
  • 学习c++的第四天

    目录 运算符 算术运算符 关系运算符 逻辑运算符 位运算符 赋值运算符 杂项运算符 运算符优先级 算术运算符是 C++ 中用于执行基本算术操作的运算符。 加法运算符 (+):将两个操作数相加。例如,A + B 将得到 30,因为 10 + 20 等于 30。 减法运算符 (-):从第一个操作数中减去第

    2024年02月06日
    浏览(44)
  • 学习c++的第九天

    目录 结构体 定义与访问结构 结构作为函数参数 指向结构的指针 typedef 示例 1:为结构体创建类型别名 示例 2:为函数指针创建类型别名 在C++中,结构体(structure)是一种用户自定义的数据类型,用于组合不同类型的数据成员。结构体可以包含变量、函数和其他数据

    2024年02月05日
    浏览(33)
  • 第一百二十二天学习记录:C++提高:STL-vector容器(上)(黑马教学视频)

    功能: vector数据结构和数组非常相似,也称为单端数组 vector与普通数组区别: 不同之处在于数组是静态空间,而vector可以动态扩展 动态扩展: 并不是在原空间之后续接新的空间,而是找更大的内存空间,然后将原数据拷贝新空间,释放原空间 vector容器的迭代器是支持随机

    2024年02月14日
    浏览(43)
  • 学习C语言的第一天

    使用工具:visual studio 2010 搭建过程:新建项目、配置设置(主要是解决运行后一闪而过的问题)   如何输出各种数据类型?  学习字节以及一些常用基本单位:  搞懂十进制和二进制如何计算?  从以上内容,我们可以得出:如果我使用的是int类型,那么将有32个bit,也就是

    2023年04月18日
    浏览(58)
  • 小白学习c++的的第一节课

    经过了很长时间对C语言和c的数据结构学习,终于开始学C++了。前面基础不牢,后面地动山摇,给自己加油。 该如何去学习c++? 多写博客。写博客,主要是总结自己学习的知识,更系统更全面对所学的知识进行概况,也能起到复习的作用。 有时间的话多看看课外书 c++的学习不

    2024年02月08日
    浏览(44)
  • c++类开发的第三篇(讲明白友元函数和this指针)

    c++实现了 封装 , 数据 和 处理数据的操作(函数) 是分开存储的。 c++中的 非静态数据成员 直接内含在类对象中,就像c语言的struct一样。 成员函数并不会出现在对象中,而是作为类的一部分存储在代码段中,需要通过对象或对象指针进行调用。成员函数可以访问类的所有成员

    2024年02月21日
    浏览(45)
  • NRCE 二级C语言开发环境:Microsoft Visual C++ 2010 学习版下载

    Microsoft Visual C++ 2010 学习版 2022版考纲 网盘链接:点击下载 提取码:siyy 网盘地址下载太慢可以到:官网下载 下载完成后,是一个iso镜像文件,点击上方装载。 装载完成后,可以看到计算机处有个无穷图标的DVD驱动器 现在就可以去到你安装磁盘目录下的IDE目录(星号中间的

    2024年02月11日
    浏览(54)
  • SSM框架的学习与应用(Spring + Spring MVC + MyBatis)-Java EE企业级应用开发学习记录(第二天)Mybatis的深入学习

    上一篇我们的项目搭建好了,也写了简答的Junit测试类进行测试,可以正确映射到数据库中。 那么这篇文章来深入学习一下以下几个点: 了解 MyBatis的核心对象SqlSessionFactoryBuilder 以及它的作用 掌握MyBatis核心配置文件以及元素的使用 。 掌握MyBatis映射文件及其元素的使用 。

    2024年02月11日
    浏览(66)
  • C++类开发的第六篇(虚拟继承实现原理和cl命令的使用的bug修复)

    接上一篇末尾虚拟继承的简单介绍之后,这篇来详细讲一下这个内存大小是怎么分配的。 cl 是 Microsoft Visual Studio 中的 C/C++ 编译器命令。通过在命令行中键入 cl 命令,可以调用 Visual Studio 的编译器进行编译操作。 cl 命令提供了各种选项和参数,用于指定源文件、编译选项、

    2024年03月09日
    浏览(45)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包