Ошибка e0167 visual studio

When I try to draw lines in Visual Studio 2019 with graphics.h I keep getting 2 types of errors.

This is an example I’m trying to get to work on my compiler from geeksforgeeks.org

Errors

E0167 — argument of type «const char*» is incompatible with lies 2 parameter of type «char*» — Line 17

and

C2664 — ‘void initgraph(int*,int*,char*)’; cannot convert argument 3 from ‘const char[1] to ‘char*’ — Line 17

My code:

'''// C++ Implementation for drawing line 
#include <graphics.h> 

// driver code 
int main()
{
    // gm is Graphics mode which is a computer display 
    // mode that generates image using pixels. 
    // DETECT is a macro defined in "graphics.h" header file 
    int gd = DETECT, gm;

    // initgraph initializes the graphics system 
    // by loading a graphics driver from disk 
    initgraph(&gd, &gm, "");

    // line for x1, y1, x2, y2 
    line(150, 150, 450, 150);

    // line for x1, y1, x2, y2 
    line(150, 200, 450, 200);

    // line for x1, y1, x2, y2 
    line(150, 250, 450, 250);

    getch();

     // closegraph function closes the graphics 
    // mode and deallocates all memory allocated 
    // by graphics system . 
    closegraph();
}'''

В коде хеш таблицы у меня почему то выдается ошибка в мейне, а конкретно

int main()
{
		struct listnode *node;
	hashtab_init(hashtab);
	hashtab_add(hashtab, "Tigr", 190); // ошибка на "Tigr"
	hashtab_add(hashtab, "Slon", 2300); // ошибка на "Slon"
	hashtab_add(hashtab, "Volk", 60); // ошибка на "Volk"

	node = hashtab_lookup(hashtab, "Slon"); // ошибка на "Slon"
	printf("Node: %s, %d\n", node->key, node->value);

	return 0;
}

В код блоксе все работает.

Ошибка (активно) E0167 аргумент типа «const char *» несовместим с параметром типа «char *»

сам код.

#include <stdio.h> 
#include <stdlib.h> 
#include <string.h> 
#include "stdafx.h"
#include <math.h>
#include <tchar.h>


#define HASHTAB_SIZE 71 
#define HASHTAB_MUL 31 

struct listnode {
	char *key;
	int value;

	struct listnode *next;
};

struct listnode *hashtab[HASHTAB_SIZE];

int hashtab_hash(char *key) {
	int h = 0;
	char *p;

	for (p = key; *p != '\0'; p++) {
		h = h * HASHTAB_MUL + (int)*p;
	}
	return h % HASHTAB_SIZE;
}

void hashtab_init(struct listnode **hashtab) {
	int i;

	for (i = 0; i < HASHTAB_SIZE; i++) {
		hashtab[i] = NULL;
	}
}

int hashtab_add(struct listnode **hashtab, char *key, int value) {
	struct listnode *node;

	int index = hashtab_hash(key);

	node = (struct listnode *) malloc(sizeof(*node));
	if (node != NULL) {
		node->key = key;
		node->value = value;
		node->next = hashtab[index];
		hashtab[index] = node;
	}
	return NULL;
}

struct listnode *hashtab_lookup(
	struct listnode **hashtab, char *key)
{
	int index;
	struct listnode *node;

	index = hashtab_hash(key);
	for (node = hashtab[index]; node != NULL; node = node->next)

	{
		if (strcmp(node->key, key) == 0) {
			return node;
		}
	}
	return NULL;
}

int main()
{
		struct listnode *node;
	hashtab_init(hashtab);
	hashtab_add(hashtab, "Tigr", 190);
	hashtab_add(hashtab, "Slon", 2300);
	hashtab_add(hashtab, "Volk", 60);

	node = hashtab_lookup(hashtab, "Slon");
	printf("Node: %s, %d\n", node->key, node->value);

	return 0;
}

void hashtab_delete(struct listnode **hashtab, char *key) {
	int index;
	struct listnode *p, *prev = NULL;

	index = hashtab_hash(key);
	for (p = hashtab[index]; p != NULL; p = p->next) {
		if (strcmp(p->key, key) == 0) {
			if (prev == NULL) hashtab[index] = p->next;
			else
				prev->next = p->next;
			free(p);
			return;
		}
		prev = p;
	}
}

If you google «MSDN fopen_s» and read the documentation on the Microsoft Developer Network, you will find that the function prototype is not identical to fopen():

errno_t fopen_s(
   FILE** pFile,
   const char *filename,
   const char *mode
);

This means your code in that area would change to look like:

FILE *inFile;
errno_t errcode;

errcode = fopen_s(&inFile, "prices.dot","r"); 

if (errcode != 0) { /* do error handling, perhaps quit */ }

Alternately, you could continue to write old-style C code, and just use «fopen()» and at the top of your file, to shut MSVC compiler up, add the following #define:

#define _CRT_SECURE_NO_WARNINGS

Note, fopen_s() was added to the C 2011 standard, and is described in section K.3.5.2.1 — meaning this is still portable C code on any modern C compiler.

Your book is probably older than 2011, and this function wasn’t part of C at that time.